
;
;
;     Model statements for module:  Create 9
;

419$          CREATE,        1,HoursToBaseTime(0.0),Entity 1:HoursToBaseTime(24):NEXT(420$);

420$          ASSIGN:        Create 9.NumberOut=Create 9.NumberOut + 1:NEXT(87$);


;
;
;     Model statements for module:  Assign 64
;
87$           ASSIGN:        day=day+1:NEXT(88$);


;
;
;     Model statements for module:  Dispose 17
;
88$           ASSIGN:        Dispose 17.NumberOut=Dispose 17.NumberOut + 1;
423$          DISPOSE:       Yes;


115$          CREATE,        1,TFIN:,1:NEXT(116$);

116$          WRITE,         rqueueoutput:
                             
                             tavg(time in receiptq at d1),tavg(time in receiptq at d2),davg(statistic 1),davg(statistic 2),davg(statistic 3),dmax(statistic 1), dmax(statistic 2),dmax(statistic 3),davg(statistic 4),davg(statistic 5),davg(statistic 6),dmax(statistic 4),dmax(statistic 5),dmax(statistic 6),davg(statistic 7),dmax(statistic 7),davg(statistic 8),dmax(statistic 8);
117$          DISPOSE:       No;


124$          CREATE,        1,TFIN:,1:NEXT(125$);

125$          WRITE,         rtimeinsystem:
                             
                             tavg(time in system from d1), tavg(time in system from d2),tavg(time for putaway from d1),tavg(time for putaway from d2);
126$          DISPOSE:       No;


129$          CREATE,        1,TFIN::NEXT(130$);

130$          WRITE,         utilizationf1:
                             FSTAND(forklift1,1),FSTAND(forklift1,2),FSTAND(forklift1,4);
131$          DISPOSE:       No;


132$          CREATE,        1,TFIN::NEXT(133$);

133$          WRITE,         utilizationf2:
                             FSTAND(forklift2,1),FSTAND(forklift2,2),FSTAND(forklift2,4);
134$          DISPOSE:       No;


135$          CREATE,        1,TFIN::NEXT(136$);

136$          WRITE,         utilizationf3:
                             FSTAND(forklift3,1),FSTAND(forklift3,2),FSTAND(forklift3,4);
137$          DISPOSE:       No;


138$          CREATE,        1,TFIN::NEXT(139$);

139$          WRITE,         utilizationf5:
                             FSTAND(forklift5,1),FSTAND(forklift5,2),FSTAND(forklift5,4);
140$          DISPOSE:       No;


141$          CREATE,        1,TFIN::NEXT(142$);

142$          WRITE,         utilizationf6:
                             FSTAND(forklift6,1),FSTAND(forklift6,2),FSTAND(forklift6,4);
143$          DISPOSE:       No;


144$          CREATE,        1,TFIN::NEXT(145$);

145$          WRITE,         utilizationd1:
                             FSTAND(dock 1,1),FSTAND(dock 1,2),FSTAND(dock 1,4);
146$          DISPOSE:       No;


147$          CREATE,        1,TFIN::NEXT(148$);

148$          WRITE,         utilizationd2:
                             FSTAND(dock 2,1),FSTAND(dock 2,2),FSTAND(dock 2,4);
149$          DISPOSE:       No;


161$          CREATE,        1,TFIN:,1:NEXT(162$);

162$          WRITE,         squeueoutput:
                             
                             tavg(time in shipmentq at d1),tavg(time in shipmentq at d2),nc(dispatchatruck),nc(dispatchbtruck),nc(dispatchctruck),nc(receiptatruck),nc(receiptbtruck),nc(receiptctruck),nc(#runaway),tavg(time for pickup to d1),tavg(time for pickup to d2),tavg(time for loading at d1),tavg(time for loading at d2);
163$          DISPOSE:       No;


168$          CREATE,        1,TFIN:,1:NEXT(169$);

169$          WRITE,         stimeinsystem:
                             
                             tavg(time in system from d1 for shipment),nc(# of trucks that are in system  more than 60 minutes from d1),nc(#of trucks that are from d1),tavg(time in system from d2 for shipment),nc(# of trucks that are in system  more than 60 minutes from d2),nc(#of trucks that are from d2),nc(# of trucks that are in system  more than 45 minutes from d1),nc(# of trucks that are in system  more than 45 minutes from d2);
170$          DISPOSE:       No;


;
;
;     Model statements for module:  Create 4
;

424$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c1:MinutesToBaseTime(1440):NEXT(425$);

425$          ASSIGN:        Create for receiving b shift1 c1.NumberOut=Create for receiving b shift1 c1.NumberOut + 1
                             :NEXT(246$);


;
;
;     Model statements for module:  Decide 98
;
246$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),428$,Yes:
                             Else,429$,Yes;
428$          ASSIGN:        Decide 98.NumberOut True=Decide 98.NumberOut True + 1:NEXT(324$);

429$          ASSIGN:        Decide 98.NumberOut False=Decide 98.NumberOut False + 1:NEXT(247$);


;
;
;     Model statements for module:  Assign 198
;
324$          ASSIGN:        receiptb1# c1=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,67)
                             :NEXT(248$);


;
;
;     Model statements for module:  Decide 99
;
248$          BRANCH,        1:
                             If,receiptb1# c1==0,238$,Yes:
                             If,receiptb1# c1==1,249$,Yes:
                             Else,250$,Yes;

;
;
;     Model statements for module:  Separate 5
;
250$          DUPLICATE,     100 - 50:
                             receiptb1# c1-1,434$,50:NEXT(433$);

433$          ASSIGN:        Separate 5.NumberOut Orig=Separate 5.NumberOut Orig + 1:NEXT(249$);

434$          ASSIGN:        Separate 5.NumberOut Dup=Separate 5.NumberOut Dup + 1:NEXT(249$);


;
;
;     Model statements for module:  Process 10
;
249$          ASSIGN:        Process 10.NumberIn=Process 10.NumberIn + 1:
                             Process 10.WIP=Process 10.WIP+1;
464$          STACK,         1:Save:NEXT(438$);

438$          QUEUE,         Process 10.Queue;
437$          SEIZE,         2,VA:
                             Resource 4_1,1:NEXT(436$);

436$          DELAY:         HoursToBaseTime(expo(10/receiptb1# c1,3)),,VA:NEXT(479$);

479$          ASSIGN:        Process 10.WaitTime=Process 10.WaitTime + Diff.WaitTime;
443$          TALLY:         Process 10.WaitTimePerEntity,Diff.WaitTime,1;
445$          TALLY:         Process 10.TotalTimePerEntity,Diff.StartTime,1;
469$          ASSIGN:        Process 10.VATime=Process 10.VATime + Diff.VATime;
470$          TALLY:         Process 10.VATimePerEntity,Diff.VATime,1;
435$          RELEASE:       Resource 4_1,1;
484$          STACK,         1:Destroy:NEXT(483$);

483$          ASSIGN:        Process 10.NumberOut=Process 10.NumberOut + 1:
                             Process 10.WIP=Process 10.WIP-1:NEXT(234$);


;
;
;     Model statements for module:  Assign 57
;
234$          ASSIGN:        producttype=2:NEXT(119$);


;
;
;     Model statements for module:  Decide 121
;
119$          BRANCH,        1:
                             If,producttype==1,118$,Yes:
                             If,producttype==2,120$,Yes:
                             Else,121$,Yes;
121$          COUNT:         receiptctruck,1:NEXT(112$);


;
;
;     Model statements for module:  Assign 78
;
112$          ASSIGN:        receiptqenter=tnow:NEXT(110$);

110$          QUEUE,         receiptdockqueue;
100$          SEIZE,         2,Other:
                             SELECT(Docks,LRC,index),1:NEXT(101$);


;
;
;     Model statements for module:  Decide 116
;
101$          BRANCH,        1:
                             If,docks(index)==dock1,488$,Yes:
                             Else,489$,Yes;
488$          ASSIGN:        Decide 116.NumberOut True=Decide 116.NumberOut True + 1:NEXT(113$);

489$          ASSIGN:        Decide 116.NumberOut False=Decide 116.NumberOut False + 1:NEXT(175$);

113$          TALLY:         time in receiptq at d1,tnow-receiptqenter,1:NEXT(0$);


;
;
;     Model statements for module:  Assign 2
;
0$            ASSIGN:        truckcap=8:
                             dockno=1:NEXT(1$);

1$            DUPLICATE:     truckcap-1,68$:NEXT(68$);


;
;
;     Model statements for module:  Process 1
;
68$           ASSIGN:        Unloading from dock1.NumberIn=Unloading from dock1.NumberIn + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP+1;
519$          STACK,         1:Save:NEXT(493$);

493$          QUEUE,         Unloading from dock1.Queue;
492$          SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(491$);

491$          DELAY:         SecondsToBaseTime(UNIF(62,83,61)),,VA:NEXT(534$);

534$          ASSIGN:        Unloading from dock1.WaitTime=Unloading from dock1.WaitTime + Diff.WaitTime;
498$          TALLY:         Unloading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
500$          TALLY:         Unloading from dock1.TotalTimePerEntity,Diff.StartTime,1;
524$          ASSIGN:        Unloading from dock1.VATime=Unloading from dock1.VATime + Diff.VATime;
525$          TALLY:         Unloading from dock1.VATimePerEntity,Diff.VATime,1;
490$          RELEASE:       SELECT(TransSet4,LAST),1;
539$          STACK,         1:Destroy:NEXT(538$);

538$          ASSIGN:        Unloading from dock1.NumberOut=Unloading from dock1.NumberOut + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP-1:NEXT(177$);


;
;
;     Model statements for module:  Assign 110
;
177$          ASSIGN:        beginning time for putaway from d1=tnow:NEXT(104$);

104$          ASSIGN:        product3stock=(producttype==3)*(product3stock+1)+(producttype<>3)*(product3stock+0):
                             product2stock=(producttype==2)*(product2stock+1)+(producttype<>2)*(product2stock+0):
                             product1stock=(producttype==1)*(product1stock+1)+(producttype<>1)*(product1stock+0);
106$          WRITE,         stockr:
                             totalstock,
                             tnow:NEXT(2$);


;
;
;     Model statements for module:  Assign 3
;
2$            ASSIGN:        i=1:NEXT(3$);


;
;
;     Model statements for module:  Assign 4
;
3$            ASSIGN:        replaced=0:NEXT(4$);

4$            WHILE:         (replaced==0):NEXT(7$);


;
;
;     Model statements for module:  Decide 3
;
7$            BRANCH,        1:
                             If,(LocationA(i,1) == 0) ||  ( (producttype  ==  LocationA (i,2)) && (LocationA(i,1) < Capacity) ),
                             541$,Yes:
                             Else,542$,Yes;
541$          ASSIGN:        Decide 3.NumberOut True=Decide 3.NumberOut True + 1:NEXT(6$);

542$          ASSIGN:        Decide 3.NumberOut False=Decide 3.NumberOut False + 1:NEXT(9$);

6$            ASSIGN:        LocationA(i,1)=LocationA(i,1)+1:
                             LocationA(i,2)=producttype:NEXT(10$);


;
;
;     Model statements for module:  Assign 11
;
10$           ASSIGN:        Locationtype=1:NEXT(56$);


;
;
;     Model statements for module:  Decide 45
;
56$           BRANCH,        1:
                             If,dockno==1,543$,Yes:
                             Else,544$,Yes;
543$          ASSIGN:        Decide 45.NumberOut True=Decide 45.NumberOut True + 1:NEXT(200$);

544$          ASSIGN:        Decide 45.NumberOut False=Decide 45.NumberOut False + 1:NEXT(199$);


;
;
;     Model statements for module:  Assign 183
;
200$          ASSIGN:        width1=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance1=20+i*1+width1:NEXT(12$);


;
;
;     Model statements for module:  Assign 13
;
12$           ASSIGN:        replaced=1:NEXT(13$);

13$           ENDWHILE:NEXT(53$);


;
;
;     Model statements for module:  Decide 44
;
53$           BRANCH,        1:
                             If,dockno==1,545$,Yes:
                             Else,546$,Yes;
545$          ASSIGN:        Decide 44.NumberOut True=Decide 44.NumberOut True + 1:NEXT(15$);

546$          ASSIGN:        Decide 44.NumberOut False=Decide 44.NumberOut False + 1:NEXT(54$);


;
;
;     Model statements for module:  Seize 2
;
15$           QUEUE,         Seizing a forklift from forklift set at receiving ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet1,CYC, trans_no1),1:NEXT(548$);

548$          DELAY:         0.0,,VA:NEXT(219$);


;
;
;     Model statements for module:  Decide 229
;
219$          BRANCH,        1:
                             If,stock exceeded<>1,549$,Yes:
                             Else,550$,Yes;
549$          ASSIGN:        Decide 229.NumberOut True=Decide 229.NumberOut True + 1:NEXT(17$);

550$          ASSIGN:        Decide 229.NumberOut False=Decide 229.NumberOut False + 1:NEXT(220$);


;
;
;     Model statements for module:  Delay 1
;
17$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance1)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance3)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance5)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance7)+NORM(0,7.3))*2)),,
                             Other:NEXT(18$);

18$           RELEASE:       Member(TransSet1, Trans_No1),1;
179$          TALLY:         time for putaway from d1,tnow-beginning time for putaway from d1,1;
150$          ASSIGN:        #unloaded1=#unloaded1+1:NEXT(19$);


;
;
;     Model statements for module:  Decide 6
;
19$           BRANCH,        1:
                             If,#unloaded1==truckcap,551$,Yes:
                             Else,552$,Yes;
551$          ASSIGN:        Decide 6.NumberOut True=Decide 6.NumberOut True + 1:NEXT(20$);

552$          ASSIGN:        Decide 6.NumberOut False=Decide 6.NumberOut False + 1:NEXT(14$);


;
;
;     Model statements for module:  Release 1
;
20$           RELEASE:       dock1,1:NEXT(123$);

123$          TALLY:         time in system from d1,tnow-receiptqenter,1;
151$          ASSIGN:        #unloaded1=#unloaded1-#unloaded1:NEXT(14$);


;
;
;     Model statements for module:  Dispose 1
;
14$           ASSIGN:        Dispose 1.NumberOut=Dispose 1.NumberOut + 1;
553$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Delay 14
;
220$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(18$);


;
;
;     Model statements for module:  Seize 15
;
54$           QUEUE,         Seizing a forklift from forklift set at receiving ramp2.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet2,CYC, trans_no2),1:NEXT(555$);

555$          DELAY:         0.0,,VA:NEXT(222$);


;
;
;     Model statements for module:  Decide 230
;
222$          BRANCH,        1:
                             If,stock exceeded<>1,556$,Yes:
                             Else,557$,Yes;
556$          ASSIGN:        Decide 230.NumberOut True=Decide 230.NumberOut True + 1:NEXT(57$);

557$          ASSIGN:        Decide 230.NumberOut False=Decide 230.NumberOut False + 1:NEXT(221$);


;
;
;     Model statements for module:  Delay 11
;
57$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance2)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance4)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance6)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance8)+NORM(0,7.3))*2)),,
                             Other:NEXT(58$);

58$           RELEASE:       Member(TransSet2, Trans_No2),1;
180$          TALLY:         time for putaway from d2,tnow-beginning time for putaway from d2,1;
152$          ASSIGN:        #unloaded2=#unloaded2+1:NEXT(60$);


;
;
;     Model statements for module:  Decide 56
;
60$           BRANCH,        1:
                             If,#unloaded2==truckcap,558$,Yes:
                             Else,559$,Yes;
558$          ASSIGN:        Decide 56.NumberOut True=Decide 56.NumberOut True + 1:NEXT(61$);

559$          ASSIGN:        Decide 56.NumberOut False=Decide 56.NumberOut False + 1:NEXT(59$);


;
;
;     Model statements for module:  Release 15
;
61$           RELEASE:       dock2,1:NEXT(122$);

122$          TALLY:         time in system from d2,tnow-receiptqenter,1;
153$          ASSIGN:        #unloaded2=#unloaded2-#unloaded2:NEXT(59$);


;
;
;     Model statements for module:  Dispose 15
;
59$           ASSIGN:        Dispose 15.NumberOut=Dispose 15.NumberOut + 1;
560$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Delay 15
;
221$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(58$);


;
;
;     Model statements for module:  Assign 182
;
199$          ASSIGN:        width2=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance2=23+i*1+width2:NEXT(12$);


;
;
;     Model statements for module:  Decide 4
;
9$            BRANCH,        1:
                             If,
                             ((LocationB(i,1) == 0) ||  ( (producttype  ==  LocationB (i,2)) && (LocationB(i,1) < Capacity) )),
                             561$,Yes:
                             Else,562$,Yes;
561$          ASSIGN:        Decide 4.NumberOut True=Decide 4.NumberOut True + 1:NEXT(5$);

562$          ASSIGN:        Decide 4.NumberOut False=Decide 4.NumberOut False + 1:NEXT(70$);

5$            ASSIGN:        LocationB(i,1)=LocationB(i,1)+1:
                             LocationB(i,2)=producttype:NEXT(11$);


;
;
;     Model statements for module:  Assign 12
;
11$           ASSIGN:        Locationtype=2:NEXT(201$);


;
;
;     Model statements for module:  Decide 223
;
201$          BRANCH,        1:
                             If,dockno==1,563$,Yes:
                             Else,564$,Yes;
563$          ASSIGN:        Decide 223.NumberOut True=Decide 223.NumberOut True + 1:NEXT(202$);

564$          ASSIGN:        Decide 223.NumberOut False=Decide 223.NumberOut False + 1:NEXT(203$);


;
;
;     Model statements for module:  Assign 184
;
202$          ASSIGN:        width3=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance3=20+i*1+width3:NEXT(12$);


;
;
;     Model statements for module:  Assign 186
;
203$          ASSIGN:        width4=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance4=23+i*1+width4:NEXT(12$);


;
;
;     Model statements for module:  Decide 67
;
70$           BRANCH,        1:
                             If,((LocationC(i,1) == 0) ||  ( (producttype  ==  LocationC (i,2)) && (LocationC(i,1) < 8) )),565$,
                             Yes:
                             Else,566$,Yes;
565$          ASSIGN:        Decide 67.NumberOut True=Decide 67.NumberOut True + 1:NEXT(71$);

566$          ASSIGN:        Decide 67.NumberOut False=Decide 67.NumberOut False + 1:NEXT(89$);

71$           ASSIGN:        LocationC(i,1)=LocationC(i,1)+1:
                             LocationC(i,2)=producttype:NEXT(72$);


;
;
;     Model statements for module:  Assign 49
;
72$           ASSIGN:        Locationtype=3:NEXT(73$);


;
;
;     Model statements for module:  Decide 68
;
73$           BRANCH,        1:
                             If,dockno==1,567$,Yes:
                             Else,568$,Yes;
567$          ASSIGN:        Decide 68.NumberOut True=Decide 68.NumberOut True + 1:NEXT(74$);

568$          ASSIGN:        Decide 68.NumberOut False=Decide 68.NumberOut False + 1:NEXT(75$);


;
;
;     Model statements for module:  Assign 51
;
74$           ASSIGN:        width5=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance5=13+i*1+width5:NEXT(12$);


;
;
;     Model statements for module:  Assign 52
;
75$           ASSIGN:        width6=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance6=14+i*1+width6:NEXT(12$);


;
;
;     Model statements for module:  Decide 110
;
89$           BRANCH,        1:
                             If,((LocationD(i,1) == 0) ||  ( (producttype  ==  LocationD (i,2)) && (LocationD(i,1) < 8) )),569$,
                             Yes:
                             Else,570$,Yes;
569$          ASSIGN:        Decide 110.NumberOut True=Decide 110.NumberOut True + 1:NEXT(90$);

570$          ASSIGN:        Decide 110.NumberOut False=Decide 110.NumberOut False + 1:NEXT(8$);

90$           ASSIGN:        LocationD(i,1)=LocationD(i,1)+1:
                             LocationD(i,2)=producttype:NEXT(91$);


;
;
;     Model statements for module:  Assign 76
;
91$           ASSIGN:        Locationtype=4:NEXT(204$);


;
;
;     Model statements for module:  Decide 224
;
204$          BRANCH,        1:
                             If,dockno==1,571$,Yes:
                             Else,572$,Yes;
571$          ASSIGN:        Decide 224.NumberOut True=Decide 224.NumberOut True + 1:NEXT(205$);

572$          ASSIGN:        Decide 224.NumberOut False=Decide 224.NumberOut False + 1:NEXT(206$);


;
;
;     Model statements for module:  Assign 189
;
205$          ASSIGN:        width7=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance7=13+i*1+width7:NEXT(12$);


;
;
;     Model statements for module:  Assign 190
;
206$          ASSIGN:        width8=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance8=14+i*1+width8:NEXT(12$);


;
;
;     Model statements for module:  Assign 10
;
8$            ASSIGN:        i=i+1:NEXT(217$);


;
;
;     Model statements for module:  Decide 228
;
217$          BRANCH,        1:
                             If,i<=231,573$,Yes:
                             Else,574$,Yes;
573$          ASSIGN:        Decide 228.NumberOut True=Decide 228.NumberOut True + 1:NEXT(13$);

574$          ASSIGN:        Decide 228.NumberOut False=Decide 228.NumberOut False + 1:NEXT(218$);


;
;
;     Model statements for module:  Assign 196
;
218$          ASSIGN:        stock exceeded=1:NEXT(213$);


;
;
;     Model statements for module:  Decide 227
;
213$          BRANCH,        1:
                             If,producttype==1,214$,Yes:
                             If,producttype==2,215$,Yes:
                             Else,216$,Yes;
216$          ASSIGN:        stock3=stock3+1:NEXT(53$);

214$          ASSIGN:        stock1=stock1+1:NEXT(53$);

215$          ASSIGN:        stock2=stock2+1:NEXT(53$);

175$          TALLY:         time in receiptq at d2,tnow-receiptqenter,1:NEXT(21$);


;
;
;     Model statements for module:  Assign 15
;
21$           ASSIGN:        truckcap=8:
                             dockno=2:NEXT(22$);

22$           DUPLICATE:     truckcap-1,69$:NEXT(69$);


;
;
;     Model statements for module:  Process 2
;
69$           ASSIGN:        Unloading from dock2.NumberIn=Unloading from dock2.NumberIn + 1:
                             Unloading from dock2.WIP=Unloading from dock2.WIP+1;
606$          STACK,         1:Save:NEXT(580$);

580$          QUEUE,         Unloading from dock2.Queue;
579$          SEIZE,         1,VA:
                             SELECT(TransSet5,SNB, ),1:NEXT(578$);

578$          DELAY:         SecondsToBaseTime(UNIF(62,83,62)),,VA:NEXT(621$);

621$          ASSIGN:        Unloading from dock2.WaitTime=Unloading from dock2.WaitTime + Diff.WaitTime;
585$          TALLY:         Unloading from dock2.WaitTimePerEntity,Diff.WaitTime,1;
587$          TALLY:         Unloading from dock2.TotalTimePerEntity,Diff.StartTime,1;
611$          ASSIGN:        Unloading from dock2.VATime=Unloading from dock2.VATime + Diff.VATime;
612$          TALLY:         Unloading from dock2.VATimePerEntity,Diff.VATime,1;
577$          RELEASE:       SELECT(TransSet5,LAST),1;
626$          STACK,         1:Destroy:NEXT(625$);

625$          ASSIGN:        Unloading from dock2.NumberOut=Unloading from dock2.NumberOut + 1:
                             Unloading from dock2.WIP=Unloading from dock2.WIP-1:NEXT(178$);


;
;
;     Model statements for module:  Assign 111
;
178$          ASSIGN:        beginning time for putaway from d2=tnow:NEXT(104$);

118$          COUNT:         receiptatruck,1:NEXT(112$);

120$          COUNT:         receiptbtruck,1:NEXT(112$);


;
;
;     Model statements for module:  Dispose 16
;
238$          ASSIGN:        Dispose 16.NumberOut=Dispose 16.NumberOut + 1;
628$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 69
;
247$          ASSIGN:        receiptb2# c1=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,68)
                             :NEXT(251$);


;
;
;     Model statements for module:  Decide 100
;
251$          BRANCH,        1:
                             If,receiptb2# c1==0,238$,Yes:
                             If,receiptb2# c1==1,252$,Yes:
                             Else,253$,Yes;

;
;
;     Model statements for module:  Separate 6
;
253$          DUPLICATE,     100 - 50:
                             receiptb2# c1-1,633$,50:NEXT(632$);

632$          ASSIGN:        Separate 6.NumberOut Orig=Separate 6.NumberOut Orig + 1:NEXT(252$);

633$          ASSIGN:        Separate 6.NumberOut Dup=Separate 6.NumberOut Dup + 1:NEXT(252$);


;
;
;     Model statements for module:  Process 11
;
252$          ASSIGN:        Process 11.NumberIn=Process 11.NumberIn + 1:
                             Process 11.WIP=Process 11.WIP+1;
663$          STACK,         1:Save:NEXT(637$);

637$          QUEUE,         Process 11.Queue;
636$          SEIZE,         2,VA:
                             Resource 5,1:NEXT(635$);

635$          DELAY:         HoursToBaseTime(expo(14/receiptb2# c1,4)),,VA:NEXT(678$);

678$          ASSIGN:        Process 11.WaitTime=Process 11.WaitTime + Diff.WaitTime;
642$          TALLY:         Process 11.WaitTimePerEntity,Diff.WaitTime,1;
644$          TALLY:         Process 11.TotalTimePerEntity,Diff.StartTime,1;
668$          ASSIGN:        Process 11.VATime=Process 11.VATime + Diff.VATime;
669$          TALLY:         Process 11.VATimePerEntity,Diff.VATime,1;
634$          RELEASE:       Resource 5,1;
683$          STACK,         1:Destroy:NEXT(682$);

682$          ASSIGN:        Process 11.NumberOut=Process 11.NumberOut + 1:
                             Process 11.WIP=Process 11.WIP-1:NEXT(234$);


;
;
;     Model statements for module:  Create 5
;

685$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c1:MinutesToBaseTime(1440):NEXT(686$);

686$          ASSIGN:        Create for receiving c shift1 c1.NumberOut=Create for receiving c shift1 c1.NumberOut + 1
                             :NEXT(254$);


;
;
;     Model statements for module:  Decide 101
;
254$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),689$,Yes:
                             Else,690$,Yes;
689$          ASSIGN:        Decide 101.NumberOut True=Decide 101.NumberOut True + 1:NEXT(255$);

690$          ASSIGN:        Decide 101.NumberOut False=Decide 101.NumberOut False + 1:NEXT(256$);


;
;
;     Model statements for module:  Assign 70
;
255$          ASSIGN:        receiptc1# c1=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,69)
                             :NEXT(257$);


;
;
;     Model statements for module:  Decide 102
;
257$          BRANCH,        1:
                             If,receiptc1# c1==0,238$,Yes:
                             If,receiptc1# c1==1,258$,Yes:
                             Else,259$,Yes;

;
;
;     Model statements for module:  Separate 7
;
259$          DUPLICATE,     100 - 50:
                             receiptc1# c1-1,695$,50:NEXT(694$);

694$          ASSIGN:        Separate 7.NumberOut Orig=Separate 7.NumberOut Orig + 1:NEXT(258$);

695$          ASSIGN:        Separate 7.NumberOut Dup=Separate 7.NumberOut Dup + 1:NEXT(258$);


;
;
;     Model statements for module:  Process 12
;
258$          ASSIGN:        Process 12.NumberIn=Process 12.NumberIn + 1:
                             Process 12.WIP=Process 12.WIP+1;
725$          STACK,         1:Save:NEXT(699$);

699$          QUEUE,         Process 12.Queue;
698$          SEIZE,         2,VA:
                             Resource 6,1:NEXT(697$);

697$          DELAY:         HoursToBaseTime(expo(10/receiptc1# c1,5)),,VA:NEXT(740$);

740$          ASSIGN:        Process 12.WaitTime=Process 12.WaitTime + Diff.WaitTime;
704$          TALLY:         Process 12.WaitTimePerEntity,Diff.WaitTime,1;
706$          TALLY:         Process 12.TotalTimePerEntity,Diff.StartTime,1;
730$          ASSIGN:        Process 12.VATime=Process 12.VATime + Diff.VATime;
731$          TALLY:         Process 12.VATimePerEntity,Diff.VATime,1;
696$          RELEASE:       Resource 6,1;
745$          STACK,         1:Destroy:NEXT(744$);

744$          ASSIGN:        Process 12.NumberOut=Process 12.NumberOut + 1:
                             Process 12.WIP=Process 12.WIP-1:NEXT(235$);


;
;
;     Model statements for module:  Assign 58
;
235$          ASSIGN:        producttype=3:NEXT(119$);


;
;
;     Model statements for module:  Assign 71
;
256$          ASSIGN:        receiptc2# c1=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,70)
                             :NEXT(260$);


;
;
;     Model statements for module:  Decide 103
;
260$          BRANCH,        1:
                             If,receiptc2# c1==0,238$,Yes:
                             If,receiptc2# c1==1,261$,Yes:
                             Else,262$,Yes;

;
;
;     Model statements for module:  Separate 8
;
262$          DUPLICATE,     100 - 50:
                             receiptc2# c1-1,751$,50:NEXT(750$);

750$          ASSIGN:        Separate 8.NumberOut Orig=Separate 8.NumberOut Orig + 1:NEXT(261$);

751$          ASSIGN:        Separate 8.NumberOut Dup=Separate 8.NumberOut Dup + 1:NEXT(261$);


;
;
;     Model statements for module:  Process 13
;
261$          ASSIGN:        Process 13.NumberIn=Process 13.NumberIn + 1:
                             Process 13.WIP=Process 13.WIP+1;
781$          STACK,         1:Save:NEXT(755$);

755$          QUEUE,         Process 13.Queue;
754$          SEIZE,         2,VA:
                             Resource 7,1:NEXT(753$);

753$          DELAY:         HoursToBaseTime(expo(14/receiptc2# c1,6)),,VA:NEXT(796$);

796$          ASSIGN:        Process 13.WaitTime=Process 13.WaitTime + Diff.WaitTime;
760$          TALLY:         Process 13.WaitTimePerEntity,Diff.WaitTime,1;
762$          TALLY:         Process 13.TotalTimePerEntity,Diff.StartTime,1;
786$          ASSIGN:        Process 13.VATime=Process 13.VATime + Diff.VATime;
787$          TALLY:         Process 13.VATimePerEntity,Diff.VATime,1;
752$          RELEASE:       Resource 7,1;
801$          STACK,         1:Destroy:NEXT(800$);

800$          ASSIGN:        Process 13.NumberOut=Process 13.NumberOut + 1:
                             Process 13.WIP=Process 13.WIP-1:NEXT(235$);


;
;
;     Model statements for module:  Create 11
;

803$          CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c1:MinutesToBaseTime(1440):NEXT(804$);

804$          ASSIGN:        Create for receiving a shift2 c1.NumberOut=Create for receiving a shift2 c1.NumberOut + 1
                             :NEXT(241$);


;
;
;     Model statements for module:  Decide 93
;
241$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),807$,Yes:
                             Else,808$,Yes;
807$          ASSIGN:        Decide 93.NumberOut True=Decide 93.NumberOut True + 1:NEXT(236$);

808$          ASSIGN:        Decide 93.NumberOut False=Decide 93.NumberOut False + 1:NEXT(242$);


;
;
;     Model statements for module:  Assign 62
;
236$          ASSIGN:        receipta1# c1=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,65)
                             :NEXT(237$);


;
;
;     Model statements for module:  Decide 92
;
237$          BRANCH,        1:
                             If,receipta1# c1==0,238$,Yes:
                             If,receipta1# c1==1,239$,Yes:
                             Else,240$,Yes;

;
;
;     Model statements for module:  Separate 1
;
240$          DUPLICATE,     100 - 50:
                             receipta1# c1-1,813$,50:NEXT(812$);

812$          ASSIGN:        Separate 1.NumberOut Orig=Separate 1.NumberOut Orig + 1:NEXT(239$);

813$          ASSIGN:        Separate 1.NumberOut Dup=Separate 1.NumberOut Dup + 1:NEXT(239$);


;
;
;     Model statements for module:  Process 6
;
239$          ASSIGN:        Process 6.NumberIn=Process 6.NumberIn + 1:
                             Process 6.WIP=Process 6.WIP+1;
843$          STACK,         1:Save:NEXT(817$);

817$          QUEUE,         Process 6.Queue;
816$          SEIZE,         2,VA:
                             Resource 1,1:NEXT(815$);

815$          DELAY:         HoursToBaseTime(expo(10/receipta1# c1,1)),,VA:NEXT(858$);

858$          ASSIGN:        Process 6.WaitTime=Process 6.WaitTime + Diff.WaitTime;
822$          TALLY:         Process 6.WaitTimePerEntity,Diff.WaitTime,1;
824$          TALLY:         Process 6.TotalTimePerEntity,Diff.StartTime,1;
848$          ASSIGN:        Process 6.VATime=Process 6.VATime + Diff.VATime;
849$          TALLY:         Process 6.VATimePerEntity,Diff.VATime,1;
814$          RELEASE:       Resource 1,1;
863$          STACK,         1:Destroy:NEXT(862$);

862$          ASSIGN:        Process 6.NumberOut=Process 6.NumberOut + 1:
                             Process 6.WIP=Process 6.WIP-1:NEXT(233$);


;
;
;     Model statements for module:  Assign 1
;
233$          ASSIGN:        producttype=1:NEXT(119$);


;
;
;     Model statements for module:  Assign 65
;
242$          ASSIGN:        receipta2# c1=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,66)
                             :NEXT(243$);


;
;
;     Model statements for module:  Decide 94
;
243$          BRANCH,        1:
                             If,receipta2# c1==0,238$,Yes:
                             If,receipta2# c1==1,245$,Yes:
                             Else,244$,Yes;

;
;
;     Model statements for module:  Separate 2
;
244$          DUPLICATE,     100 - 50:
                             receipta2# c1-1,869$,50:NEXT(868$);

868$          ASSIGN:        Separate 2.NumberOut Orig=Separate 2.NumberOut Orig + 1:NEXT(245$);

869$          ASSIGN:        Separate 2.NumberOut Dup=Separate 2.NumberOut Dup + 1:NEXT(245$);


;
;
;     Model statements for module:  Process 8
;
245$          ASSIGN:        Process 8.NumberIn=Process 8.NumberIn + 1:
                             Process 8.WIP=Process 8.WIP+1;
899$          STACK,         1:Save:NEXT(873$);

873$          QUEUE,         Process 8.Queue;
872$          SEIZE,         2,VA:
                             Resource 2,1:NEXT(871$);

871$          DELAY:         HoursToBaseTime(expo(14/receipta2# c1,2)),,VA:NEXT(914$);

914$          ASSIGN:        Process 8.WaitTime=Process 8.WaitTime + Diff.WaitTime;
878$          TALLY:         Process 8.WaitTimePerEntity,Diff.WaitTime,1;
880$          TALLY:         Process 8.TotalTimePerEntity,Diff.StartTime,1;
904$          ASSIGN:        Process 8.VATime=Process 8.VATime + Diff.VATime;
905$          TALLY:         Process 8.VATimePerEntity,Diff.VATime,1;
870$          RELEASE:       Resource 2,1;
919$          STACK,         1:Destroy:NEXT(918$);

918$          ASSIGN:        Process 8.NumberOut=Process 8.NumberOut + 1:
                             Process 8.WIP=Process 8.WIP-1:NEXT(233$);


;
;
;     Model statements for module:  Create 16
;

921$          CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c1:MinutesToBaseTime(1440):NEXT(922$);

922$          ASSIGN:        Create for receiving b shift2 c1.NumberOut=Create for receiving b shift2 c1.NumberOut + 1
                             :NEXT(246$);


;
;
;     Model statements for module:  Create 17
;

925$          CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c1:MinutesToBaseTime(1440):NEXT(926$);

926$          ASSIGN:        Create for receiving c shift2 c1.NumberOut=Create for receiving c shift2 c1.NumberOut + 1
                             :NEXT(254$);


;
;
;     Model statements for module:  Create 24
;

929$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c2:MinutesToBaseTime(1440):NEXT(930$);

930$          ASSIGN:        Create for receiving b shift1 c2.NumberOut=Create for receiving b shift1 c2.NumberOut + 1
                             :NEXT(276$);


;
;
;     Model statements for module:  Decide 127
;
276$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),933$,Yes:
                             Else,934$,Yes;
933$          ASSIGN:        Decide 127.NumberOut True=Decide 127.NumberOut True + 1:NEXT(325$);

934$          ASSIGN:        Decide 127.NumberOut False=Decide 127.NumberOut False + 1:NEXT(277$);


;
;
;     Model statements for module:  Assign 199
;
325$          ASSIGN:        receiptb1# c2=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,73)
                             :NEXT(278$);


;
;
;     Model statements for module:  Decide 128
;
278$          BRANCH,        1:
                             If,receiptb1# c2==0,268$,Yes:
                             If,receiptb1# c2==1,279$,Yes:
                             Else,280$,Yes;

;
;
;     Model statements for module:  Separate 15
;
280$          DUPLICATE,     100 - 50:
                             receiptb1# c2-1,939$,50:NEXT(938$);

938$          ASSIGN:        Separate 15.NumberOut Orig=Separate 15.NumberOut Orig + 1:NEXT(279$);

939$          ASSIGN:        Separate 15.NumberOut Dup=Separate 15.NumberOut Dup + 1:NEXT(279$);


;
;
;     Model statements for module:  Process 20
;
279$          ASSIGN:        Process 20.NumberIn=Process 20.NumberIn + 1:
                             Process 20.WIP=Process 20.WIP+1;
969$          STACK,         1:Save:NEXT(943$);

943$          QUEUE,         Process 20.Queue;
942$          SEIZE,         2,VA:
                             Resource 14,1:NEXT(941$);

941$          DELAY:         HoursToBaseTime(expo(10/receiptb1# c2,9)),,VA:NEXT(984$);

984$          ASSIGN:        Process 20.WaitTime=Process 20.WaitTime + Diff.WaitTime;
948$          TALLY:         Process 20.WaitTimePerEntity,Diff.WaitTime,1;
950$          TALLY:         Process 20.TotalTimePerEntity,Diff.StartTime,1;
974$          ASSIGN:        Process 20.VATime=Process 20.VATime + Diff.VATime;
975$          TALLY:         Process 20.VATimePerEntity,Diff.VATime,1;
940$          RELEASE:       Resource 14,1;
989$          STACK,         1:Destroy:NEXT(988$);

988$          ASSIGN:        Process 20.NumberOut=Process 20.NumberOut + 1:
                             Process 20.WIP=Process 20.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Assign 83
;
264$          ASSIGN:        producttype=2:NEXT(119$);


;
;
;     Model statements for module:  Dispose 22
;
268$          ASSIGN:        Dispose 22.NumberOut=Dispose 22.NumberOut + 1;
991$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 88
;
277$          ASSIGN:        receiptb2# c2=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,74)
                             :NEXT(281$);


;
;
;     Model statements for module:  Decide 129
;
281$          BRANCH,        1:
                             If,receiptb2# c2==0,268$,Yes:
                             If,receiptb2# c2==1,282$,Yes:
                             Else,283$,Yes;

;
;
;     Model statements for module:  Separate 16
;
283$          DUPLICATE,     100 - 50:
                             receiptb2# c2-1,996$,50:NEXT(995$);

995$          ASSIGN:        Separate 16.NumberOut Orig=Separate 16.NumberOut Orig + 1:NEXT(282$);

996$          ASSIGN:        Separate 16.NumberOut Dup=Separate 16.NumberOut Dup + 1:NEXT(282$);


;
;
;     Model statements for module:  Process 21
;
282$          ASSIGN:        Process 21.NumberIn=Process 21.NumberIn + 1:
                             Process 21.WIP=Process 21.WIP+1;
1026$         STACK,         1:Save:NEXT(1000$);

1000$         QUEUE,         Process 21.Queue;
999$          SEIZE,         2,VA:
                             Resource 15,1:NEXT(998$);

998$          DELAY:         HoursToBaseTime(expo(14/receiptb2# c2,10)),,VA:NEXT(1041$);

1041$         ASSIGN:        Process 21.WaitTime=Process 21.WaitTime + Diff.WaitTime;
1005$         TALLY:         Process 21.WaitTimePerEntity,Diff.WaitTime,1;
1007$         TALLY:         Process 21.TotalTimePerEntity,Diff.StartTime,1;
1031$         ASSIGN:        Process 21.VATime=Process 21.VATime + Diff.VATime;
1032$         TALLY:         Process 21.VATimePerEntity,Diff.VATime,1;
997$          RELEASE:       Resource 15,1;
1046$         STACK,         1:Destroy:NEXT(1045$);

1045$         ASSIGN:        Process 21.NumberOut=Process 21.NumberOut + 1:
                             Process 21.WIP=Process 21.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Create 25
;

1048$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c2:MinutesToBaseTime(1440):NEXT(1049$);

1049$         ASSIGN:        Create for receiving c shift1 c2.NumberOut=Create for receiving c shift1 c2.NumberOut + 1
                             :NEXT(284$);


;
;
;     Model statements for module:  Decide 130
;
284$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1052$,Yes:
                             Else,1053$,Yes;
1052$         ASSIGN:        Decide 130.NumberOut True=Decide 130.NumberOut True + 1:NEXT(285$);

1053$         ASSIGN:        Decide 130.NumberOut False=Decide 130.NumberOut False + 1:NEXT(286$);


;
;
;     Model statements for module:  Assign 89
;
285$          ASSIGN:        receiptc1# c2=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,75)
                             :NEXT(287$);


;
;
;     Model statements for module:  Decide 131
;
287$          BRANCH,        1:
                             If,receiptc1# c2==0,268$,Yes:
                             If,receiptc1# c2==1,288$,Yes:
                             Else,289$,Yes;

;
;
;     Model statements for module:  Separate 17
;
289$          DUPLICATE,     100 - 50:
                             receiptc1# c2-1,1058$,50:NEXT(1057$);

1057$         ASSIGN:        Separate 17.NumberOut Orig=Separate 17.NumberOut Orig + 1:NEXT(288$);

1058$         ASSIGN:        Separate 17.NumberOut Dup=Separate 17.NumberOut Dup + 1:NEXT(288$);


;
;
;     Model statements for module:  Process 22
;
288$          ASSIGN:        Process 22.NumberIn=Process 22.NumberIn + 1:
                             Process 22.WIP=Process 22.WIP+1;
1088$         STACK,         1:Save:NEXT(1062$);

1062$         QUEUE,         Process 22.Queue;
1061$         SEIZE,         2,VA:
                             Resource 16,1:NEXT(1060$);

1060$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c2,11)),,VA:NEXT(1103$);

1103$         ASSIGN:        Process 22.WaitTime=Process 22.WaitTime + Diff.WaitTime;
1067$         TALLY:         Process 22.WaitTimePerEntity,Diff.WaitTime,1;
1069$         TALLY:         Process 22.TotalTimePerEntity,Diff.StartTime,1;
1093$         ASSIGN:        Process 22.VATime=Process 22.VATime + Diff.VATime;
1094$         TALLY:         Process 22.VATimePerEntity,Diff.VATime,1;
1059$         RELEASE:       Resource 16,1;
1108$         STACK,         1:Destroy:NEXT(1107$);

1107$         ASSIGN:        Process 22.NumberOut=Process 22.NumberOut + 1:
                             Process 22.WIP=Process 22.WIP-1:NEXT(265$);


;
;
;     Model statements for module:  Assign 84
;
265$          ASSIGN:        producttype=3:NEXT(119$);


;
;
;     Model statements for module:  Assign 90
;
286$          ASSIGN:        receiptc2# c2=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,76)
                             :NEXT(290$);


;
;
;     Model statements for module:  Decide 132
;
290$          BRANCH,        1:
                             If,receiptc2# c2==0,268$,Yes:
                             If,receiptc2# c2==1,291$,Yes:
                             Else,292$,Yes;

;
;
;     Model statements for module:  Separate 18
;
292$          DUPLICATE,     100 - 50:
                             receiptc2# c2-1,1114$,50:NEXT(1113$);

1113$         ASSIGN:        Separate 18.NumberOut Orig=Separate 18.NumberOut Orig + 1:NEXT(291$);

1114$         ASSIGN:        Separate 18.NumberOut Dup=Separate 18.NumberOut Dup + 1:NEXT(291$);


;
;
;     Model statements for module:  Process 23
;
291$          ASSIGN:        Process 23.NumberIn=Process 23.NumberIn + 1:
                             Process 23.WIP=Process 23.WIP+1;
1144$         STACK,         1:Save:NEXT(1118$);

1118$         QUEUE,         Process 23.Queue;
1117$         SEIZE,         2,VA:
                             Resource 17,1:NEXT(1116$);

1116$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c2,12)),,VA:NEXT(1159$);

1159$         ASSIGN:        Process 23.WaitTime=Process 23.WaitTime + Diff.WaitTime;
1123$         TALLY:         Process 23.WaitTimePerEntity,Diff.WaitTime,1;
1125$         TALLY:         Process 23.TotalTimePerEntity,Diff.StartTime,1;
1149$         ASSIGN:        Process 23.VATime=Process 23.VATime + Diff.VATime;
1150$         TALLY:         Process 23.VATimePerEntity,Diff.VATime,1;
1115$         RELEASE:       Resource 17,1;
1164$         STACK,         1:Destroy:NEXT(1163$);

1163$         ASSIGN:        Process 23.NumberOut=Process 23.NumberOut + 1:
                             Process 23.WIP=Process 23.WIP-1:NEXT(265$);


;
;
;     Model statements for module:  Create 27
;

1166$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c2:MinutesToBaseTime(1440):NEXT(1167$);

1167$         ASSIGN:        Create for receiving a shift2 c2.NumberOut=Create for receiving a shift2 c2.NumberOut + 1
                             :NEXT(271$);


;
;
;     Model statements for module:  Decide 125
;
271$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1170$,Yes:
                             Else,1171$,Yes;
1170$         ASSIGN:        Decide 125.NumberOut True=Decide 125.NumberOut True + 1:NEXT(266$);

1171$         ASSIGN:        Decide 125.NumberOut False=Decide 125.NumberOut False + 1:NEXT(272$);


;
;
;     Model statements for module:  Assign 85
;
266$          ASSIGN:        receipta1# c2=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,71)
                             :NEXT(267$);


;
;
;     Model statements for module:  Decide 124
;
267$          BRANCH,        1:
                             If,receipta1# c2==0,268$,Yes:
                             If,receipta1# c2==1,269$,Yes:
                             Else,270$,Yes;

;
;
;     Model statements for module:  Separate 13
;
270$          DUPLICATE,     100 - 50:
                             receipta1# c2-1,1176$,50:NEXT(1175$);

1175$         ASSIGN:        Separate 13.NumberOut Orig=Separate 13.NumberOut Orig + 1:NEXT(269$);

1176$         ASSIGN:        Separate 13.NumberOut Dup=Separate 13.NumberOut Dup + 1:NEXT(269$);


;
;
;     Model statements for module:  Process 18
;
269$          ASSIGN:        Process 18.NumberIn=Process 18.NumberIn + 1:
                             Process 18.WIP=Process 18.WIP+1;
1206$         STACK,         1:Save:NEXT(1180$);

1180$         QUEUE,         Process 18.Queue;
1179$         SEIZE,         2,VA:
                             Resource 12,1:NEXT(1178$);

1178$         DELAY:         HoursToBaseTime(expo(10/receipta1# c2,7)),,VA:NEXT(1221$);

1221$         ASSIGN:        Process 18.WaitTime=Process 18.WaitTime + Diff.WaitTime;
1185$         TALLY:         Process 18.WaitTimePerEntity,Diff.WaitTime,1;
1187$         TALLY:         Process 18.TotalTimePerEntity,Diff.StartTime,1;
1211$         ASSIGN:        Process 18.VATime=Process 18.VATime + Diff.VATime;
1212$         TALLY:         Process 18.VATimePerEntity,Diff.VATime,1;
1177$         RELEASE:       Resource 12,1;
1226$         STACK,         1:Destroy:NEXT(1225$);

1225$         ASSIGN:        Process 18.NumberOut=Process 18.NumberOut + 1:
                             Process 18.WIP=Process 18.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Assign 82
;
263$          ASSIGN:        producttype=1:NEXT(119$);


;
;
;     Model statements for module:  Assign 86
;
272$          ASSIGN:        receipta2# c2=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,72)
                             :NEXT(273$);


;
;
;     Model statements for module:  Decide 126
;
273$          BRANCH,        1:
                             If,receipta2# c2==0,268$,Yes:
                             If,receipta2# c2==1,275$,Yes:
                             Else,274$,Yes;

;
;
;     Model statements for module:  Separate 14
;
274$          DUPLICATE,     100 - 50:
                             receipta2# c2-1,1232$,50:NEXT(1231$);

1231$         ASSIGN:        Separate 14.NumberOut Orig=Separate 14.NumberOut Orig + 1:NEXT(275$);

1232$         ASSIGN:        Separate 14.NumberOut Dup=Separate 14.NumberOut Dup + 1:NEXT(275$);


;
;
;     Model statements for module:  Process 19
;
275$          ASSIGN:        Process 19.NumberIn=Process 19.NumberIn + 1:
                             Process 19.WIP=Process 19.WIP+1;
1262$         STACK,         1:Save:NEXT(1236$);

1236$         QUEUE,         Process 19.Queue;
1235$         SEIZE,         2,VA:
                             Resource 13,1:NEXT(1234$);

1234$         DELAY:         HoursToBaseTime(expo(14/receipta2# c2,8)),,VA:NEXT(1277$);

1277$         ASSIGN:        Process 19.WaitTime=Process 19.WaitTime + Diff.WaitTime;
1241$         TALLY:         Process 19.WaitTimePerEntity,Diff.WaitTime,1;
1243$         TALLY:         Process 19.TotalTimePerEntity,Diff.StartTime,1;
1267$         ASSIGN:        Process 19.VATime=Process 19.VATime + Diff.VATime;
1268$         TALLY:         Process 19.VATimePerEntity,Diff.VATime,1;
1233$         RELEASE:       Resource 13,1;
1282$         STACK,         1:Destroy:NEXT(1281$);

1281$         ASSIGN:        Process 19.NumberOut=Process 19.NumberOut + 1:
                             Process 19.WIP=Process 19.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Create 28
;

1284$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c2:MinutesToBaseTime(1440):NEXT(1285$);

1285$         ASSIGN:        Create for receiving b shift2 c2.NumberOut=Create for receiving b shift2 c2.NumberOut + 1
                             :NEXT(276$);


;
;
;     Model statements for module:  Create 29
;

1288$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c2:MinutesToBaseTime(1440):NEXT(1289$);

1289$         ASSIGN:        Create for receiving c shift2 c2.NumberOut=Create for receiving c shift2 c2.NumberOut + 1
                             :NEXT(284$);


;
;
;     Model statements for module:  Create 45
;

1292$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c3:MinutesToBaseTime(1440):NEXT(1293$);

1293$         ASSIGN:        Create for receiving b shift1 c3.NumberOut=Create for receiving b shift1 c3.NumberOut + 1
                             :NEXT(306$);


;
;
;     Model statements for module:  Decide 157
;
306$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1296$,Yes:
                             Else,1297$,Yes;
1296$         ASSIGN:        Decide 157.NumberOut True=Decide 157.NumberOut True + 1:NEXT(307$);

1297$         ASSIGN:        Decide 157.NumberOut False=Decide 157.NumberOut False + 1:NEXT(308$);


;
;
;     Model statements for module:  Assign 117
;
307$          ASSIGN:        receiptb1# c3=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,79)
                             :NEXT(309$);


;
;
;     Model statements for module:  Decide 158
;
309$          BRANCH,        1:
                             If,receiptb1# c3==0,298$,Yes:
                             If,receiptb1# c3==1,310$,Yes:
                             Else,311$,Yes;

;
;
;     Model statements for module:  Separate 33
;
311$          DUPLICATE,     100 - 50:
                             receiptb1# c3-1,1302$,50:NEXT(1301$);

1301$         ASSIGN:        Separate 33.NumberOut Orig=Separate 33.NumberOut Orig + 1:NEXT(310$);

1302$         ASSIGN:        Separate 33.NumberOut Dup=Separate 33.NumberOut Dup + 1:NEXT(310$);


;
;
;     Model statements for module:  Process 38
;
310$          ASSIGN:        Process 38.NumberIn=Process 38.NumberIn + 1:
                             Process 38.WIP=Process 38.WIP+1;
1332$         STACK,         1:Save:NEXT(1306$);

1306$         QUEUE,         Process 38.Queue;
1305$         SEIZE,         2,VA:
                             Resource 26,1:NEXT(1304$);

1304$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c3,15)),,VA:NEXT(1347$);

1347$         ASSIGN:        Process 38.WaitTime=Process 38.WaitTime + Diff.WaitTime;
1311$         TALLY:         Process 38.WaitTimePerEntity,Diff.WaitTime,1;
1313$         TALLY:         Process 38.TotalTimePerEntity,Diff.StartTime,1;
1337$         ASSIGN:        Process 38.VATime=Process 38.VATime + Diff.VATime;
1338$         TALLY:         Process 38.VATimePerEntity,Diff.VATime,1;
1303$         RELEASE:       Resource 26,1;
1352$         STACK,         1:Destroy:NEXT(1351$);

1351$         ASSIGN:        Process 38.NumberOut=Process 38.NumberOut + 1:
                             Process 38.WIP=Process 38.WIP-1:NEXT(294$);


;
;
;     Model statements for module:  Assign 113
;
294$          ASSIGN:        producttype=2:NEXT(119$);


;
;
;     Model statements for module:  Dispose 25
;
298$          ASSIGN:        Dispose 25.NumberOut=Dispose 25.NumberOut + 1;
1354$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 118
;
308$          ASSIGN:        receiptb2# c3=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,80)
                             :NEXT(312$);


;
;
;     Model statements for module:  Decide 159
;
312$          BRANCH,        1:
                             If,receiptb2# c3==0,298$,Yes:
                             If,receiptb2# c3==1,313$,Yes:
                             Else,314$,Yes;

;
;
;     Model statements for module:  Separate 34
;
314$          DUPLICATE,     100 - 50:
                             receiptb2# c3-1,1359$,50:NEXT(1358$);

1358$         ASSIGN:        Separate 34.NumberOut Orig=Separate 34.NumberOut Orig + 1:NEXT(313$);

1359$         ASSIGN:        Separate 34.NumberOut Dup=Separate 34.NumberOut Dup + 1:NEXT(313$);


;
;
;     Model statements for module:  Process 39
;
313$          ASSIGN:        Process 39.NumberIn=Process 39.NumberIn + 1:
                             Process 39.WIP=Process 39.WIP+1;
1389$         STACK,         1:Save:NEXT(1363$);

1363$         QUEUE,         Process 39.Queue;
1362$         SEIZE,         2,VA:
                             Resource 27,1:NEXT(1361$);

1361$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c3,16)),,VA:NEXT(1404$);

1404$         ASSIGN:        Process 39.WaitTime=Process 39.WaitTime + Diff.WaitTime;
1368$         TALLY:         Process 39.WaitTimePerEntity,Diff.WaitTime,1;
1370$         TALLY:         Process 39.TotalTimePerEntity,Diff.StartTime,1;
1394$         ASSIGN:        Process 39.VATime=Process 39.VATime + Diff.VATime;
1395$         TALLY:         Process 39.VATimePerEntity,Diff.VATime,1;
1360$         RELEASE:       Resource 27,1;
1409$         STACK,         1:Destroy:NEXT(1408$);

1408$         ASSIGN:        Process 39.NumberOut=Process 39.NumberOut + 1:
                             Process 39.WIP=Process 39.WIP-1:NEXT(294$);


;
;
;     Model statements for module:  Create 46
;

1411$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c3:MinutesToBaseTime(1440):NEXT(1412$);

1412$         ASSIGN:        Create for receiving c shift1 c3.NumberOut=Create for receiving c shift1 c3.NumberOut + 1
                             :NEXT(315$);


;
;
;     Model statements for module:  Decide 160
;
315$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1415$,Yes:
                             Else,1416$,Yes;
1415$         ASSIGN:        Decide 160.NumberOut True=Decide 160.NumberOut True + 1:NEXT(316$);

1416$         ASSIGN:        Decide 160.NumberOut False=Decide 160.NumberOut False + 1:NEXT(317$);


;
;
;     Model statements for module:  Assign 119
;
316$          ASSIGN:        receiptc1# c3=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,81)
                             :NEXT(318$);


;
;
;     Model statements for module:  Decide 161
;
318$          BRANCH,        1:
                             If,receiptc1# c3==0,298$,Yes:
                             If,receiptc1# c3==1,319$,Yes:
                             Else,320$,Yes;

;
;
;     Model statements for module:  Separate 35
;
320$          DUPLICATE,     100 - 50:
                             receiptc1# c3-1,1421$,50:NEXT(1420$);

1420$         ASSIGN:        Separate 35.NumberOut Orig=Separate 35.NumberOut Orig + 1:NEXT(319$);

1421$         ASSIGN:        Separate 35.NumberOut Dup=Separate 35.NumberOut Dup + 1:NEXT(319$);


;
;
;     Model statements for module:  Process 40
;
319$          ASSIGN:        Process 40.NumberIn=Process 40.NumberIn + 1:
                             Process 40.WIP=Process 40.WIP+1;
1451$         STACK,         1:Save:NEXT(1425$);

1425$         QUEUE,         Process 40.Queue;
1424$         SEIZE,         2,VA:
                             Resource 28,1:NEXT(1423$);

1423$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c3,17)),,VA:NEXT(1466$);

1466$         ASSIGN:        Process 40.WaitTime=Process 40.WaitTime + Diff.WaitTime;
1430$         TALLY:         Process 40.WaitTimePerEntity,Diff.WaitTime,1;
1432$         TALLY:         Process 40.TotalTimePerEntity,Diff.StartTime,1;
1456$         ASSIGN:        Process 40.VATime=Process 40.VATime + Diff.VATime;
1457$         TALLY:         Process 40.VATimePerEntity,Diff.VATime,1;
1422$         RELEASE:       Resource 28,1;
1471$         STACK,         1:Destroy:NEXT(1470$);

1470$         ASSIGN:        Process 40.NumberOut=Process 40.NumberOut + 1:
                             Process 40.WIP=Process 40.WIP-1:NEXT(295$);


;
;
;     Model statements for module:  Assign 114
;
295$          ASSIGN:        producttype=3:NEXT(119$);


;
;
;     Model statements for module:  Assign 120
;
317$          ASSIGN:        receiptc2# c3=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,82)
                             :NEXT(321$);


;
;
;     Model statements for module:  Decide 162
;
321$          BRANCH,        1:
                             If,receiptc2# c3==0,298$,Yes:
                             If,receiptc2# c3==1,322$,Yes:
                             Else,323$,Yes;

;
;
;     Model statements for module:  Separate 36
;
323$          DUPLICATE,     100 - 50:
                             receiptc2# c3-1,1477$,50:NEXT(1476$);

1476$         ASSIGN:        Separate 36.NumberOut Orig=Separate 36.NumberOut Orig + 1:NEXT(322$);

1477$         ASSIGN:        Separate 36.NumberOut Dup=Separate 36.NumberOut Dup + 1:NEXT(322$);


;
;
;     Model statements for module:  Process 41
;
322$          ASSIGN:        Process 41.NumberIn=Process 41.NumberIn + 1:
                             Process 41.WIP=Process 41.WIP+1;
1507$         STACK,         1:Save:NEXT(1481$);

1481$         QUEUE,         Process 41.Queue;
1480$         SEIZE,         2,VA:
                             Resource 29,1:NEXT(1479$);

1479$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c3,18)),,VA:NEXT(1522$);

1522$         ASSIGN:        Process 41.WaitTime=Process 41.WaitTime + Diff.WaitTime;
1486$         TALLY:         Process 41.WaitTimePerEntity,Diff.WaitTime,1;
1488$         TALLY:         Process 41.TotalTimePerEntity,Diff.StartTime,1;
1512$         ASSIGN:        Process 41.VATime=Process 41.VATime + Diff.VATime;
1513$         TALLY:         Process 41.VATimePerEntity,Diff.VATime,1;
1478$         RELEASE:       Resource 29,1;
1527$         STACK,         1:Destroy:NEXT(1526$);

1526$         ASSIGN:        Process 41.NumberOut=Process 41.NumberOut + 1:
                             Process 41.WIP=Process 41.WIP-1:NEXT(295$);


;
;
;     Model statements for module:  Create 48
;

1529$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c3:MinutesToBaseTime(1440):NEXT(1530$);

1530$         ASSIGN:        Create for receiving a shift2 c3.NumberOut=Create for receiving a shift2 c3.NumberOut + 1
                             :NEXT(301$);


;
;
;     Model statements for module:  Decide 155
;
301$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1533$,Yes:
                             Else,1534$,Yes;
1533$         ASSIGN:        Decide 155.NumberOut True=Decide 155.NumberOut True + 1:NEXT(296$);

1534$         ASSIGN:        Decide 155.NumberOut False=Decide 155.NumberOut False + 1:NEXT(302$);


;
;
;     Model statements for module:  Assign 115
;
296$          ASSIGN:        receipta1# c3=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,77)
                             :NEXT(297$);


;
;
;     Model statements for module:  Decide 154
;
297$          BRANCH,        1:
                             If,receipta1# c3==0,298$,Yes:
                             If,receipta1# c3==1,299$,Yes:
                             Else,300$,Yes;

;
;
;     Model statements for module:  Separate 31
;
300$          DUPLICATE,     100 - 50:
                             receipta1# c3-1,1539$,50:NEXT(1538$);

1538$         ASSIGN:        Separate 31.NumberOut Orig=Separate 31.NumberOut Orig + 1:NEXT(299$);

1539$         ASSIGN:        Separate 31.NumberOut Dup=Separate 31.NumberOut Dup + 1:NEXT(299$);


;
;
;     Model statements for module:  Process 36
;
299$          ASSIGN:        Process 36.NumberIn=Process 36.NumberIn + 1:
                             Process 36.WIP=Process 36.WIP+1;
1569$         STACK,         1:Save:NEXT(1543$);

1543$         QUEUE,         Process 36.Queue;
1542$         SEIZE,         2,VA:
                             Resource 24,1:NEXT(1541$);

1541$         DELAY:         HoursToBaseTime(expo(10/receipta1# c3,13)),,VA:NEXT(1584$);

1584$         ASSIGN:        Process 36.WaitTime=Process 36.WaitTime + Diff.WaitTime;
1548$         TALLY:         Process 36.WaitTimePerEntity,Diff.WaitTime,1;
1550$         TALLY:         Process 36.TotalTimePerEntity,Diff.StartTime,1;
1574$         ASSIGN:        Process 36.VATime=Process 36.VATime + Diff.VATime;
1575$         TALLY:         Process 36.VATimePerEntity,Diff.VATime,1;
1540$         RELEASE:       Resource 24,1;
1589$         STACK,         1:Destroy:NEXT(1588$);

1588$         ASSIGN:        Process 36.NumberOut=Process 36.NumberOut + 1:
                             Process 36.WIP=Process 36.WIP-1:NEXT(293$);


;
;
;     Model statements for module:  Assign 112
;
293$          ASSIGN:        producttype=1:NEXT(119$);


;
;
;     Model statements for module:  Assign 116
;
302$          ASSIGN:        receipta2# c3=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,78)
                             :NEXT(303$);


;
;
;     Model statements for module:  Decide 156
;
303$          BRANCH,        1:
                             If,receipta2# c3==0,298$,Yes:
                             If,receipta2# c3==1,305$,Yes:
                             Else,304$,Yes;

;
;
;     Model statements for module:  Separate 32
;
304$          DUPLICATE,     100 - 50:
                             receipta2# c3-1,1595$,50:NEXT(1594$);

1594$         ASSIGN:        Separate 32.NumberOut Orig=Separate 32.NumberOut Orig + 1:NEXT(305$);

1595$         ASSIGN:        Separate 32.NumberOut Dup=Separate 32.NumberOut Dup + 1:NEXT(305$);


;
;
;     Model statements for module:  Process 37
;
305$          ASSIGN:        Process 37.NumberIn=Process 37.NumberIn + 1:
                             Process 37.WIP=Process 37.WIP+1;
1625$         STACK,         1:Save:NEXT(1599$);

1599$         QUEUE,         Process 37.Queue;
1598$         SEIZE,         2,VA:
                             Resource 25,1:NEXT(1597$);

1597$         DELAY:         HoursToBaseTime(expo(14/receipta2# c3,14)),,VA:NEXT(1640$);

1640$         ASSIGN:        Process 37.WaitTime=Process 37.WaitTime + Diff.WaitTime;
1604$         TALLY:         Process 37.WaitTimePerEntity,Diff.WaitTime,1;
1606$         TALLY:         Process 37.TotalTimePerEntity,Diff.StartTime,1;
1630$         ASSIGN:        Process 37.VATime=Process 37.VATime + Diff.VATime;
1631$         TALLY:         Process 37.VATimePerEntity,Diff.VATime,1;
1596$         RELEASE:       Resource 25,1;
1645$         STACK,         1:Destroy:NEXT(1644$);

1644$         ASSIGN:        Process 37.NumberOut=Process 37.NumberOut + 1:
                             Process 37.WIP=Process 37.WIP-1:NEXT(293$);


;
;
;     Model statements for module:  Create 49
;

1647$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c3:MinutesToBaseTime(1440):NEXT(1648$);

1648$         ASSIGN:        Create for receiving b shift2 c3.NumberOut=Create for receiving b shift2 c3.NumberOut + 1
                             :NEXT(306$);


;
;
;     Model statements for module:  Create 50
;

1651$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c3:MinutesToBaseTime(1440):NEXT(1652$);

1652$         ASSIGN:        Create for receiving c shift2 c3.NumberOut=Create for receiving c shift2 c3.NumberOut + 1
                             :NEXT(315$);


;
;
;     Model statements for module:  Create 99
;

1655$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c2:MinutesToBaseTime(1440):NEXT(1656$);

1656$         ASSIGN:        Create for receiving a shift1 c2.NumberOut=Create for receiving a shift1 c2.NumberOut + 1
                             :NEXT(271$);


;
;
;     Model statements for module:  Create 100
;

1659$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c1:MinutesToBaseTime(1440):NEXT(1660$);

1660$         ASSIGN:        Create for receiving a shift1 c1.NumberOut=Create for receiving a shift1 c1.NumberOut + 1
                             :NEXT(241$);


;
;
;     Model statements for module:  Create 103
;

1663$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c3:MinutesToBaseTime(1440):NEXT(1664$);

1664$         ASSIGN:        Create for receiving a shift1 c3.NumberOut=Create for receiving a shift1 c3.NumberOut + 1
                             :NEXT(301$);


;
;
;     Model statements for module:  Create 6
;

1667$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c1:MinutesToBaseTime(1440):NEXT(1668$);

1668$         ASSIGN:        Create for shipment b shift1 c1.NumberOut=Create for shipment b shift1 c1.NumberOut + 1:NEXT(339$);


;
;
;     Model statements for module:  Decide 104
;
339$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1671$,Yes:
                             Else,1672$,Yes;
1671$         ASSIGN:        Decide 104.NumberOut True=Decide 104.NumberOut True + 1:NEXT(340$);

1672$         ASSIGN:        Decide 104.NumberOut False=Decide 104.NumberOut False + 1:NEXT(341$);


;
;
;     Model statements for module:  Assign 72
;
340$          ASSIGN:        departureb1# c1=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,97):NEXT(342$);


;
;
;     Model statements for module:  Decide 105
;
342$          BRANCH,        1:
                             If,departureb1# c1==0,333$,Yes:
                             If,departureb1# c1==1,343$,Yes:
                             Else,344$,Yes;

;
;
;     Model statements for module:  Separate 9
;
344$          DUPLICATE,     100 - 50:
                             departureb1# c1-1,1677$,50:NEXT(1676$);

1676$         ASSIGN:        Separate 9.NumberOut Orig=Separate 9.NumberOut Orig + 1:NEXT(343$);

1677$         ASSIGN:        Separate 9.NumberOut Dup=Separate 9.NumberOut Dup + 1:NEXT(343$);


;
;
;     Model statements for module:  Process 14
;
343$          ASSIGN:        Process 14.NumberIn=Process 14.NumberIn + 1:
                             Process 14.WIP=Process 14.WIP+1;
1707$         STACK,         1:Save:NEXT(1681$);

1681$         QUEUE,         Process 14.Queue;
1680$         SEIZE,         2,VA:
                             Resource 8,1:NEXT(1679$);

1679$         DELAY:         HoursToBaseTime(expo(10/departureb1# c1,33)),,VA:NEXT(1722$);

1722$         ASSIGN:        Process 14.WaitTime=Process 14.WaitTime + Diff.WaitTime;
1686$         TALLY:         Process 14.WaitTimePerEntity,Diff.WaitTime,1;
1688$         TALLY:         Process 14.TotalTimePerEntity,Diff.StartTime,1;
1712$         ASSIGN:        Process 14.VATime=Process 14.VATime + Diff.VATime;
1713$         TALLY:         Process 14.VATimePerEntity,Diff.VATime,1;
1678$         RELEASE:       Resource 8,1;
1727$         STACK,         1:Destroy:NEXT(1726$);

1726$         ASSIGN:        Process 14.NumberOut=Process 14.NumberOut + 1:
                             Process 14.WIP=Process 14.WIP-1:NEXT(327$);


;
;
;     Model statements for module:  Assign 60
;
327$          ASSIGN:        type=2:NEXT(97$);


;
;
;     Model statements for module:  Decide 115
;
97$           BRANCH,        1:
                             If,type==1,107$,Yes:
                             If,type==2,108$,Yes:
                             Else,109$,Yes;

;
;
;     Model statements for module:  Decide 120
;
109$          BRANCH,        1:
                             If,product3stock>=safety stock,1731$,Yes:
                             Else,1732$,Yes;
1731$         ASSIGN:        Decide 120.NumberOut True=Decide 120.NumberOut True + 1:NEXT(160$);

1732$         ASSIGN:        Decide 120.NumberOut False=Decide 120.NumberOut False + 1:NEXT(99$);

160$          COUNT:         dispatchctruck,1:NEXT(23$);


;
;
;     Model statements for module:  Assign 23
;
23$           ASSIGN:        ordersize=8:
                             shipmentqenter=tnow:NEXT(67$);

67$           ASSIGN:        product2stock=(type==2)*(product2stock-8)+(type<>2)*(product2stock-0):
                             product3stock=(type==3)*(product3stock-8)+(type<>3)*(product3stock-0):
                             product1stock=(type==1)*(product1stock-8)+(type<>1)*(product1stock-0);
105$          WRITE,         stock:
                             totalstock,
                             tnow;
111$          QUEUE,         shipmentdockqueue;
102$          SEIZE,         1,Other:
                             SELECT(S_docks,LRC,s_index),1:NEXT(103$);


;
;
;     Model statements for module:  Decide 117
;
103$          BRANCH,        1:
                             If,s_docks(s_index)==dock1,1733$,Yes:
                             Else,1734$,Yes;
1733$         ASSIGN:        Decide 117.NumberOut True=Decide 117.NumberOut True + 1:NEXT(114$);

1734$         ASSIGN:        Decide 117.NumberOut False=Decide 117.NumberOut False + 1:NEXT(176$);

114$          TALLY:         time in shipmentq at d1,tnow-shipmentqenter,1:NEXT(65$);


;
;
;     Model statements for module:  Assign 47
;
65$           ASSIGN:        dock_no=1:
                             leave the dock1 queue=tnow:NEXT(25$);

25$           DUPLICATE:     ordersize-1,24$:NEXT(24$);


;
;
;     Model statements for module:  Assign 24
;
24$           ASSIGN:        picked=0:
                             k=1:
                             totalstock=product1stock+product2stock+product3stock:
                             totalexceedingstock=stock1+stock2+stock3:NEXT(26$);

26$           WHILE:         (picked==0):NEXT(27$);


;
;
;     Model statements for module:  Decide 17
;
27$           BRANCH,        1:
                             If,( LocationA(k,1) <> 0  )  &&  ( type == LocationA(k,2) ),1735$,Yes:
                             Else,1736$,Yes;
1735$         ASSIGN:        Decide 17.NumberOut True=Decide 17.NumberOut True + 1:NEXT(28$);

1736$         ASSIGN:        Decide 17.NumberOut False=Decide 17.NumberOut False + 1:NEXT(32$);

28$           ASSIGN:        LocationA(k,1)=LocationA(k,1)-1:NEXT(29$);


;
;
;     Model statements for module:  Assign 27
;
29$           ASSIGN:        picked=1:
                             Locationtype=1:NEXT(30$);


;
;
;     Model statements for module:  Decide 18
;
30$           BRANCH,        1:
                             If,LocationA(k,1)==0,1737$,Yes:
                             Else,1738$,Yes;
1737$         ASSIGN:        Decide 18.NumberOut True=Decide 18.NumberOut True + 1:NEXT(31$);

1738$         ASSIGN:        Decide 18.NumberOut False=Decide 18.NumberOut False + 1:NEXT(62$);

31$           ASSIGN:        LocationA(k,2)=0:NEXT(62$);


;
;
;     Model statements for module:  Decide 57
;
62$           BRANCH,        1:
                             If,dock_no==1,1739$,Yes:
                             Else,1740$,Yes;
1739$         ASSIGN:        Decide 57.NumberOut True=Decide 57.NumberOut True + 1:NEXT(63$);

1740$         ASSIGN:        Decide 57.NumberOut False=Decide 57.NumberOut False + 1:NEXT(64$);


;
;
;     Model statements for module:  Assign 43
;
63$           ASSIGN:        width9=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance9=20+k*1+width9:NEXT(37$);

37$           ENDWHILE:NEXT(41$);


;
;
;     Model statements for module:  Decide 22
;
41$           BRANCH,        1:
                             If,dock_no==1,1741$,Yes:
                             Else,1742$,Yes;
1741$         ASSIGN:        Decide 22.NumberOut True=Decide 22.NumberOut True + 1:NEXT(39$);

1742$         ASSIGN:        Decide 22.NumberOut False=Decide 22.NumberOut False + 1:NEXT(49$);


;
;
;     Model statements for module:  Seize 9
;
39$           QUEUE,         Seizing a forklift from forklift set at shipment ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet3,CYC, trans_no3),1:NEXT(1744$);

1744$         DELAY:         0.0,,VA:NEXT(229$);


;
;
;     Model statements for module:  Decide 233
;
229$          BRANCH,        1:
                             If,departure from stock exceeded<>1,1745$,Yes:
                             Else,1746$,Yes;
1745$         ASSIGN:        Decide 233.NumberOut True=Decide 233.NumberOut True + 1:NEXT(42$);

1746$         ASSIGN:        Decide 233.NumberOut False=Decide 233.NumberOut False + 1:NEXT(230$);


;
;
;     Model statements for module:  Delay 5
;
42$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance9)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance11)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance13)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance15)+NORM(0,7.3))*2)),,
                             Other:NEXT(86$);

86$           RELEASE:       Member(TransSet3, trans_no3),1;
186$          ASSIGN:        #product from d1=#product from d1+1:NEXT(128$);


;
;
;     Model statements for module:  Decide 123
;
128$          BRANCH,        1:
                             If,#product from d1==8,1747$,Yes:
                             Else,1748$,Yes;
1747$         ASSIGN:        Decide 123.NumberOut True=Decide 123.NumberOut True + 1:NEXT(164$);

1748$         ASSIGN:        Decide 123.NumberOut False=Decide 123.NumberOut False + 1:NEXT(194$);

164$          TALLY:         time for pickup to d1,tnow-leave the dock1 queue,1;
187$          ASSIGN:        #product from d1=#product from d1-#product from d1:NEXT(85$);


;
;
;     Model statements for module:  Process 5
;
85$           ASSIGN:        Loading from dock1.NumberIn=Loading from dock1.NumberIn + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP+1;
1778$         STACK,         1:Save:NEXT(1752$);

1752$         QUEUE,         Loading from dock1.Queue;
1751$         SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(1750$);

1750$         DELAY:         SecondsToBaseTime(UNIF(62,83,63)),,VA:NEXT(1793$);

1793$         ASSIGN:        Loading from dock1.WaitTime=Loading from dock1.WaitTime + Diff.WaitTime;
1757$         TALLY:         Loading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
1759$         TALLY:         Loading from dock1.TotalTimePerEntity,Diff.StartTime,1;
1783$         ASSIGN:        Loading from dock1.VATime=Loading from dock1.VATime + Diff.VATime;
1784$         TALLY:         Loading from dock1.VATimePerEntity,Diff.VATime,1;
1749$         RELEASE:       SELECT(TransSet4,LAST),1;
1798$         STACK,         1:Destroy:NEXT(1797$);

1797$         ASSIGN:        Loading from dock1.NumberOut=Loading from dock1.NumberOut + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP-1:NEXT(154$);

154$          ASSIGN:        #loaded1=#loaded1+1:NEXT(45$);


;
;
;     Model statements for module:  Decide 38
;
45$           BRANCH,        1:
                             If,#loaded1==ordersize,1800$,Yes:
                             Else,1801$,Yes;
1800$         ASSIGN:        Decide 38.NumberOut True=Decide 38.NumberOut True + 1:NEXT(43$);

1801$         ASSIGN:        Decide 38.NumberOut False=Decide 38.NumberOut False + 1:NEXT(44$);


;
;
;     Model statements for module:  Release 13
;
43$           RELEASE:       dock1,1:NEXT(155$);

155$          ASSIGN:        #loaded1=#loaded1-#loaded1;
166$          TALLY:         time in system from d1 for shipment,tnow-shipmentqenter,1;
171$          COUNT:         # of trucks that are in system  more than 60 minutes from d1,(tnow-shipmentqenter)>60;
181$          COUNT:         # of trucks that are in system  more than 45 minutes from d1,(tnow-shipmentqenter)>45;
172$          COUNT:         #of trucks that are from d1,1;
184$          TALLY:         time for loading at d1,tnow-starting time of loading at d1,1:NEXT(44$);


;
;
;     Model statements for module:  Dispose 13
;
44$           ASSIGN:        Dispose 13.NumberOut=Dispose 13.NumberOut + 1;
1802$         DISPOSE:       Yes;

194$          ASSIGN:        #product being loaded from d1=#product being loaded from d1+1:NEXT(196$);


;
;
;     Model statements for module:  Decide 219
;
196$          BRANCH,        1:
                             If,#product being loaded from d1==1,1803$,Yes:
                             Else,1804$,Yes;
1803$         ASSIGN:        Decide 219.NumberOut True=Decide 219.NumberOut True + 1:NEXT(195$);

1804$         ASSIGN:        Decide 219.NumberOut False=Decide 219.NumberOut False + 1:NEXT(197$);


;
;
;     Model statements for module:  Assign 177
;
195$          ASSIGN:        starting time of loading at d1=tnow:NEXT(85$);


;
;
;     Model statements for module:  Decide 220
;
197$          BRANCH,        1:
                             If,#product being loaded from d1==7,1805$,Yes:
                             Else,1806$,Yes;
1805$         ASSIGN:        Decide 220.NumberOut True=Decide 220.NumberOut True + 1:NEXT(198$);

1806$         ASSIGN:        Decide 220.NumberOut False=Decide 220.NumberOut False + 1:NEXT(85$);

198$          ASSIGN:        #product being loaded from d1=#product being loaded from d1-#product being loaded from d1:NEXT(85$);


;
;
;     Model statements for module:  Delay 17
;
230$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(86$);


;
;
;     Model statements for module:  Seize 12
;
49$           QUEUE,         Seizing a forklift from forklift set at shipment ramp2.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet6,CYC, trans_no6),1:NEXT(1808$);

1808$         DELAY:         0.0,,VA:NEXT(231$);


;
;
;     Model statements for module:  Decide 234
;
231$          BRANCH,        1:
                             If,departure from stock exceeded<>1,1809$,Yes:
                             Else,1810$,Yes;
1809$         ASSIGN:        Decide 234.NumberOut True=Decide 234.NumberOut True + 1:NEXT(51$);

1810$         ASSIGN:        Decide 234.NumberOut False=Decide 234.NumberOut False + 1:NEXT(232$);


;
;
;     Model statements for module:  Delay 8
;
51$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance10)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance12)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance14)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance16)+NORM(0,7.3))*2)),,
                             Other:NEXT(52$);

52$           RELEASE:       Member(TransSet6, Trans_No6),1;
188$          ASSIGN:        #product from d2=#product from d2+1:NEXT(127$);


;
;
;     Model statements for module:  Decide 122
;
127$          BRANCH,        1:
                             If,#product from d2==8,1811$,Yes:
                             Else,1812$,Yes;
1811$         ASSIGN:        Decide 122.NumberOut True=Decide 122.NumberOut True + 1:NEXT(165$);

1812$         ASSIGN:        Decide 122.NumberOut False=Decide 122.NumberOut False + 1:NEXT(190$);

165$          TALLY:         time for pickup to d2,tnow-leave the dock2 queue,1;
189$          ASSIGN:        #product from d2=#product from d2-#product from d2:NEXT(76$);


;
;
;     Model statements for module:  Process 4
;
76$           ASSIGN:        Loading from dock2.NumberIn=Loading from dock2.NumberIn + 1:
                             Loading from dock2.WIP=Loading from dock2.WIP+1;
1842$         STACK,         1:Save:NEXT(1816$);

1816$         QUEUE,         Loading from dock2.Queue;
1815$         SEIZE,         1,VA:
                             SELECT(TransSet5,SNB, ),1:NEXT(1814$);

1814$         DELAY:         SecondsToBaseTime(UNIF(62,83,64)),,VA:NEXT(1857$);

1857$         ASSIGN:        Loading from dock2.WaitTime=Loading from dock2.WaitTime + Diff.WaitTime;
1821$         TALLY:         Loading from dock2.WaitTimePerEntity,Diff.WaitTime,1;
1823$         TALLY:         Loading from dock2.TotalTimePerEntity,Diff.StartTime,1;
1847$         ASSIGN:        Loading from dock2.VATime=Loading from dock2.VATime + Diff.VATime;
1848$         TALLY:         Loading from dock2.VATimePerEntity,Diff.VATime,1;
1813$         RELEASE:       SELECT(TransSet5,LAST),1;
1862$         STACK,         1:Destroy:NEXT(1861$);

1861$         ASSIGN:        Loading from dock2.NumberOut=Loading from dock2.NumberOut + 1:
                             Loading from dock2.WIP=Loading from dock2.WIP-1:NEXT(156$);

156$          ASSIGN:        #loaded2=#loaded2+1:NEXT(46$);


;
;
;     Model statements for module:  Decide 39
;
46$           BRANCH,        1:
                             If,#loaded2==ordersize,1864$,Yes:
                             Else,1865$,Yes;
1864$         ASSIGN:        Decide 39.NumberOut True=Decide 39.NumberOut True + 1:NEXT(47$);

1865$         ASSIGN:        Decide 39.NumberOut False=Decide 39.NumberOut False + 1:NEXT(48$);


;
;
;     Model statements for module:  Release 14
;
47$           RELEASE:       dock2,1:NEXT(157$);

157$          ASSIGN:        #loaded2=#loaded2-#loaded2;
167$          TALLY:         time in system from d2 for shipment,tnow-shipmentqenter,1;
173$          COUNT:         # of trucks that are in system  more than 60 minutes from d2,(tnow-shipmentqenter)>60;
182$          COUNT:         # of trucks that are in system  more than 45 minutes from d2,(tnow-shipmentqenter)>45;
174$          COUNT:         #of trucks that are from d2,1;
185$          TALLY:         time for loading at d2,tnow-starting time of loading at d2,1:NEXT(48$);


;
;
;     Model statements for module:  Dispose 14
;
48$           ASSIGN:        Dispose 14.NumberOut=Dispose 14.NumberOut + 1;
1866$         DISPOSE:       Yes;

190$          ASSIGN:        #product being loaded from d2=#product being loaded from d2+1:NEXT(191$);


;
;
;     Model statements for module:  Decide 217
;
191$          BRANCH,        1:
                             If,#product being loaded from d2==1,1867$,Yes:
                             Else,1868$,Yes;
1867$         ASSIGN:        Decide 217.NumberOut True=Decide 217.NumberOut True + 1:NEXT(183$);

1868$         ASSIGN:        Decide 217.NumberOut False=Decide 217.NumberOut False + 1:NEXT(192$);


;
;
;     Model statements for module:  Assign 176
;
183$          ASSIGN:        starting time of loading at d2=tnow:NEXT(76$);


;
;
;     Model statements for module:  Decide 218
;
192$          BRANCH,        1:
                             If,#product being loaded from d2==7,1869$,Yes:
                             Else,1870$,Yes;
1869$         ASSIGN:        Decide 218.NumberOut True=Decide 218.NumberOut True + 1:NEXT(193$);

1870$         ASSIGN:        Decide 218.NumberOut False=Decide 218.NumberOut False + 1:NEXT(76$);

193$          ASSIGN:        #product being loaded from d2=#product being loaded from d2-#product being loaded from d2:NEXT(76$);


;
;
;     Model statements for module:  Delay 21
;
232$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(52$);


;
;
;     Model statements for module:  Assign 44
;
64$           ASSIGN:        width10=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance10=23+k*1+width10:NEXT(37$);


;
;
;     Model statements for module:  Decide 19
;
32$           BRANCH,        1:
                             If,( LocationB(k,1) <> 0 )  &&  ( type == LocationB(k,2) ),1871$,Yes:
                             Else,1872$,Yes;
1871$         ASSIGN:        Decide 19.NumberOut True=Decide 19.NumberOut True + 1:NEXT(33$);

1872$         ASSIGN:        Decide 19.NumberOut False=Decide 19.NumberOut False + 1:NEXT(77$);

33$           ASSIGN:        LocationB(k,1)=LocationB(k,1)-1:NEXT(34$);


;
;
;     Model statements for module:  Assign 30
;
34$           ASSIGN:        picked=1:
                             Locationtype=2:NEXT(35$);


;
;
;     Model statements for module:  Decide 21
;
35$           BRANCH,        1:
                             If,LocationB(k,1)==0,1873$,Yes:
                             Else,1874$,Yes;
1873$         ASSIGN:        Decide 21.NumberOut True=Decide 21.NumberOut True + 1:NEXT(36$);

1874$         ASSIGN:        Decide 21.NumberOut False=Decide 21.NumberOut False + 1:NEXT(207$);

36$           ASSIGN:        LocationB(k,2)=0:NEXT(207$);


;
;
;     Model statements for module:  Decide 225
;
207$          BRANCH,        1:
                             If,dock_no==1,1875$,Yes:
                             Else,1876$,Yes;
1875$         ASSIGN:        Decide 225.NumberOut True=Decide 225.NumberOut True + 1:NEXT(208$);

1876$         ASSIGN:        Decide 225.NumberOut False=Decide 225.NumberOut False + 1:NEXT(209$);


;
;
;     Model statements for module:  Assign 191
;
208$          ASSIGN:        width11=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance11=20+k*1+width11:NEXT(37$);


;
;
;     Model statements for module:  Assign 192
;
209$          ASSIGN:        width12=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance12=23+k*1+width12:NEXT(37$);


;
;
;     Model statements for module:  Decide 82
;
77$           BRANCH,        1:
                             If,( LocationC(k,1) <> 0 )  &&  ( type == LocationC(k,2) ),1877$,Yes:
                             Else,1878$,Yes;
1877$         ASSIGN:        Decide 82.NumberOut True=Decide 82.NumberOut True + 1:NEXT(78$);

1878$         ASSIGN:        Decide 82.NumberOut False=Decide 82.NumberOut False + 1:NEXT(92$);

78$           ASSIGN:        LocationC(k,1)=LocationC(k,1)-1:NEXT(79$);


;
;
;     Model statements for module:  Assign 53
;
79$           ASSIGN:        picked=1:
                             Locationtype=3:NEXT(80$);


;
;
;     Model statements for module:  Decide 83
;
80$           BRANCH,        1:
                             If,LocationC(k,1)==0,1879$,Yes:
                             Else,1880$,Yes;
1879$         ASSIGN:        Decide 83.NumberOut True=Decide 83.NumberOut True + 1:NEXT(81$);

1880$         ASSIGN:        Decide 83.NumberOut False=Decide 83.NumberOut False + 1:NEXT(82$);

81$           ASSIGN:        LocationC(k,2)=0:NEXT(82$);


;
;
;     Model statements for module:  Decide 84
;
82$           BRANCH,        1:
                             If,dock_no==1,1881$,Yes:
                             Else,1882$,Yes;
1881$         ASSIGN:        Decide 84.NumberOut True=Decide 84.NumberOut True + 1:NEXT(83$);

1882$         ASSIGN:        Decide 84.NumberOut False=Decide 84.NumberOut False + 1:NEXT(84$);


;
;
;     Model statements for module:  Assign 55
;
83$           ASSIGN:        width13=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance13=13+k*1+width13:NEXT(37$);


;
;
;     Model statements for module:  Assign 56
;
84$           ASSIGN:        width14=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance14=14+k*1+width14:NEXT(37$);


;
;
;     Model statements for module:  Decide 111
;
92$           BRANCH,        1:
                             If,( LocationD(k,1) <> 0 )  &&  ( type == LocationD(k,2) ),1883$,Yes:
                             Else,1884$,Yes;
1883$         ASSIGN:        Decide 111.NumberOut True=Decide 111.NumberOut True + 1:NEXT(93$);

1884$         ASSIGN:        Decide 111.NumberOut False=Decide 111.NumberOut False + 1:NEXT(38$);

93$           ASSIGN:        LocationD(k,1)=LocationD(k,1)-1:NEXT(94$);


;
;
;     Model statements for module:  Assign 77
;
94$           ASSIGN:        picked=1:
                             Locationtype=4:NEXT(95$);


;
;
;     Model statements for module:  Decide 112
;
95$           BRANCH,        1:
                             If,LocationD(k,1)==0,1885$,Yes:
                             Else,1886$,Yes;
1885$         ASSIGN:        Decide 112.NumberOut True=Decide 112.NumberOut True + 1:NEXT(96$);

1886$         ASSIGN:        Decide 112.NumberOut False=Decide 112.NumberOut False + 1:NEXT(210$);

96$           ASSIGN:        LocationD(k,2)=0:NEXT(210$);


;
;
;     Model statements for module:  Decide 226
;
210$          BRANCH,        1:
                             If,dock_no==1,1887$,Yes:
                             Else,1888$,Yes;
1887$         ASSIGN:        Decide 226.NumberOut True=Decide 226.NumberOut True + 1:NEXT(211$);

1888$         ASSIGN:        Decide 226.NumberOut False=Decide 226.NumberOut False + 1:NEXT(212$);


;
;
;     Model statements for module:  Assign 193
;
211$          ASSIGN:        width15=
                             (LocationD(k,1)==7)*0+(LocationD(k,1)==6)*1+(LocationD(k,1)==5)*2+(LocationD(k,1)==4)*3+(LocationD(k,1)==3)*4+(LocationD(k,1)==2)*5+(LocationD(k,1)==1)*6+(LocationD(k,1)==0)*7:
                             distance15=13+k*1+width15:NEXT(37$);


;
;
;     Model statements for module:  Assign 194
;
212$          ASSIGN:        width16=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance16=14+k*1+width16:NEXT(37$);


;
;
;     Model statements for module:  Assign 32
;
38$           ASSIGN:        k=k+1:NEXT(223$);


;
;
;     Model statements for module:  Decide 231
;
223$          BRANCH,        1:
                             If,k<=231,1889$,Yes:
                             Else,1890$,Yes;
1889$         ASSIGN:        Decide 231.NumberOut True=Decide 231.NumberOut True + 1:NEXT(37$);

1890$         ASSIGN:        Decide 231.NumberOut False=Decide 231.NumberOut False + 1:NEXT(228$);


;
;
;     Model statements for module:  Assign 197
;
228$          ASSIGN:        departure from stock exceeded=1:NEXT(224$);


;
;
;     Model statements for module:  Decide 232
;
224$          BRANCH,        1:
                             If,type==1,225$,Yes:
                             If,type==2,226$,Yes:
                             Else,227$,Yes;
227$          ASSIGN:        stock3=stock3-1:NEXT(41$);

225$          ASSIGN:        stock1=stock1-1:NEXT(41$);

226$          ASSIGN:        stock2=stock2-1:NEXT(41$);

176$          TALLY:         time in shipmentq at d2,tnow-shipmentqenter,1:NEXT(66$);


;
;
;     Model statements for module:  Assign 48
;
66$           ASSIGN:        dock_no=2:
                             leave the dock2 queue=tnow:NEXT(25$);


;
;
;     Model statements for module:  Record 32
;
99$           COUNT:         #runaway,1:NEXT(98$);


;
;
;     Model statements for module:  Dispose 21
;
98$           ASSIGN:        Dispose 21.NumberOut=Dispose 21.NumberOut + 1;
1893$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Decide 118
;
107$          BRANCH,        1:
                             If,product1stock>=safety stock,1894$,Yes:
                             Else,1895$,Yes;
1894$         ASSIGN:        Decide 118.NumberOut True=Decide 118.NumberOut True + 1:NEXT(158$);

1895$         ASSIGN:        Decide 118.NumberOut False=Decide 118.NumberOut False + 1:NEXT(99$);

158$          COUNT:         dispatchatruck,1:NEXT(23$);


;
;
;     Model statements for module:  Decide 119
;
108$          BRANCH,        1:
                             If,product2stock>=safety stock,1896$,Yes:
                             Else,1897$,Yes;
1896$         ASSIGN:        Decide 119.NumberOut True=Decide 119.NumberOut True + 1:NEXT(159$);

1897$         ASSIGN:        Decide 119.NumberOut False=Decide 119.NumberOut False + 1:NEXT(99$);

159$          COUNT:         dispatchbtruck,1:NEXT(23$);


;
;
;     Model statements for module:  Dispose 20
;
333$          ASSIGN:        Dispose 20.NumberOut=Dispose 20.NumberOut + 1;
1898$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 73
;
341$          ASSIGN:        departureb2# c1=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,98)
                             :NEXT(345$);


;
;
;     Model statements for module:  Decide 106
;
345$          BRANCH,        1:
                             If,departureb2# c1==0,333$,Yes:
                             If,departureb2# c1==1,346$,Yes:
                             Else,347$,Yes;

;
;
;     Model statements for module:  Separate 10
;
347$          DUPLICATE,     100 - 50:
                             departureb2# c1-1,1903$,50:NEXT(1902$);

1902$         ASSIGN:        Separate 10.NumberOut Orig=Separate 10.NumberOut Orig + 1:NEXT(346$);

1903$         ASSIGN:        Separate 10.NumberOut Dup=Separate 10.NumberOut Dup + 1:NEXT(346$);


;
;
;     Model statements for module:  Process 15
;
346$          ASSIGN:        Process 15.NumberIn=Process 15.NumberIn + 1:
                             Process 15.WIP=Process 15.WIP+1;
1933$         STACK,         1:Save:NEXT(1907$);

1907$         QUEUE,         Process 15.Queue;
1906$         SEIZE,         2,VA:
                             Resource 9,1:NEXT(1905$);

1905$         DELAY:         HoursToBaseTime(expo(14/departureb2# c1,34)),,VA:NEXT(1948$);

1948$         ASSIGN:        Process 15.WaitTime=Process 15.WaitTime + Diff.WaitTime;
1912$         TALLY:         Process 15.WaitTimePerEntity,Diff.WaitTime,1;
1914$         TALLY:         Process 15.TotalTimePerEntity,Diff.StartTime,1;
1938$         ASSIGN:        Process 15.VATime=Process 15.VATime + Diff.VATime;
1939$         TALLY:         Process 15.VATimePerEntity,Diff.VATime,1;
1904$         RELEASE:       Resource 9,1;
1953$         STACK,         1:Destroy:NEXT(1952$);

1952$         ASSIGN:        Process 15.NumberOut=Process 15.NumberOut + 1:
                             Process 15.WIP=Process 15.WIP-1:NEXT(327$);


;
;
;     Model statements for module:  Create 7
;

1955$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c1:MinutesToBaseTime(1440):NEXT(1956$);

1956$         ASSIGN:        Create for shipment c shift1 c1.NumberOut=Create for shipment c shift1 c1.NumberOut + 1:NEXT(348$);


;
;
;     Model statements for module:  Decide 107
;
348$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1959$,Yes:
                             Else,1960$,Yes;
1959$         ASSIGN:        Decide 107.NumberOut True=Decide 107.NumberOut True + 1:NEXT(349$);

1960$         ASSIGN:        Decide 107.NumberOut False=Decide 107.NumberOut False + 1:NEXT(350$);


;
;
;     Model statements for module:  Assign 74
;
349$          ASSIGN:        departurec1# c1=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,99):NEXT(351$);


;
;
;     Model statements for module:  Decide 108
;
351$          BRANCH,        1:
                             If,departurec1# c1==0,333$,Yes:
                             If,departurec1# c1==1,352$,Yes:
                             Else,353$,Yes;

;
;
;     Model statements for module:  Separate 11
;
353$          DUPLICATE,     100 - 50:
                             departurec1# c1-1,1965$,50:NEXT(1964$);

1964$         ASSIGN:        Separate 11.NumberOut Orig=Separate 11.NumberOut Orig + 1:NEXT(352$);

1965$         ASSIGN:        Separate 11.NumberOut Dup=Separate 11.NumberOut Dup + 1:NEXT(352$);


;
;
;     Model statements for module:  Process 16
;
352$          ASSIGN:        Process 16.NumberIn=Process 16.NumberIn + 1:
                             Process 16.WIP=Process 16.WIP+1;
1995$         STACK,         1:Save:NEXT(1969$);

1969$         QUEUE,         Process 16.Queue;
1968$         SEIZE,         2,VA:
                             Resource 10,1:NEXT(1967$);

1967$         DELAY:         HoursToBaseTime(expo(10/departurec1# c1,35)),,VA:NEXT(2010$);

2010$         ASSIGN:        Process 16.WaitTime=Process 16.WaitTime + Diff.WaitTime;
1974$         TALLY:         Process 16.WaitTimePerEntity,Diff.WaitTime,1;
1976$         TALLY:         Process 16.TotalTimePerEntity,Diff.StartTime,1;
2000$         ASSIGN:        Process 16.VATime=Process 16.VATime + Diff.VATime;
2001$         TALLY:         Process 16.VATimePerEntity,Diff.VATime,1;
1966$         RELEASE:       Resource 10,1;
2015$         STACK,         1:Destroy:NEXT(2014$);

2014$         ASSIGN:        Process 16.NumberOut=Process 16.NumberOut + 1:
                             Process 16.WIP=Process 16.WIP-1:NEXT(328$);


;
;
;     Model statements for module:  Assign 61
;
328$          ASSIGN:        type=3:NEXT(97$);


;
;
;     Model statements for module:  Assign 75
;
350$          ASSIGN:        departurec2# c1=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,100):NEXT(354$);


;
;
;     Model statements for module:  Decide 109
;
354$          BRANCH,        1:
                             If,departurec2# c1==0,333$,Yes:
                             If,departurec2# c1==1,355$,Yes:
                             Else,356$,Yes;

;
;
;     Model statements for module:  Separate 12
;
356$          DUPLICATE,     100 - 50:
                             departurec2# c1-1,2021$,50:NEXT(2020$);

2020$         ASSIGN:        Separate 12.NumberOut Orig=Separate 12.NumberOut Orig + 1:NEXT(355$);

2021$         ASSIGN:        Separate 12.NumberOut Dup=Separate 12.NumberOut Dup + 1:NEXT(355$);


;
;
;     Model statements for module:  Process 17
;
355$          ASSIGN:        Process 17.NumberIn=Process 17.NumberIn + 1:
                             Process 17.WIP=Process 17.WIP+1;
2051$         STACK,         1:Save:NEXT(2025$);

2025$         QUEUE,         Process 17.Queue;
2024$         SEIZE,         2,VA:
                             Resource 11,1:NEXT(2023$);

2023$         DELAY:         HoursToBaseTime(expo(14/departurec2# c1,36)),,VA:NEXT(2066$);

2066$         ASSIGN:        Process 17.WaitTime=Process 17.WaitTime + Diff.WaitTime;
2030$         TALLY:         Process 17.WaitTimePerEntity,Diff.WaitTime,1;
2032$         TALLY:         Process 17.TotalTimePerEntity,Diff.StartTime,1;
2056$         ASSIGN:        Process 17.VATime=Process 17.VATime + Diff.VATime;
2057$         TALLY:         Process 17.VATimePerEntity,Diff.VATime,1;
2022$         RELEASE:       Resource 11,1;
2071$         STACK,         1:Destroy:NEXT(2070$);

2070$         ASSIGN:        Process 17.NumberOut=Process 17.NumberOut + 1:
                             Process 17.WIP=Process 17.WIP-1:NEXT(328$);


;
;
;     Model statements for module:  Create 15
;

2073$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c1:MinutesToBaseTime(1440):NEXT(2074$);

2074$         ASSIGN:        Create for shipmenta shift2 c1.NumberOut=Create for shipmenta shift2 c1.NumberOut + 1:NEXT(330$);


;
;
;     Model statements for module:  Decide 95
;
330$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2077$,Yes:
                             Else,2078$,Yes;
2077$         ASSIGN:        Decide 95.NumberOut True=Decide 95.NumberOut True + 1:NEXT(329$);

2078$         ASSIGN:        Decide 95.NumberOut False=Decide 95.NumberOut False + 1:NEXT(331$);


;
;
;     Model statements for module:  Assign 66
;
329$          ASSIGN:        departurea1# c1=disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,95)
                             :NEXT(332$);


;
;
;     Model statements for module:  Decide 96
;
332$          BRANCH,        1:
                             If,departurea1# c1==0,333$,Yes:
                             If,departurea1# c1==1,334$,Yes:
                             Else,335$,Yes;

;
;
;     Model statements for module:  Separate 3
;
335$          DUPLICATE,     100 - 50:
                             departurea1# c1-1,2083$,50:NEXT(2082$);

2082$         ASSIGN:        Separate 3.NumberOut Orig=Separate 3.NumberOut Orig + 1:NEXT(334$);

2083$         ASSIGN:        Separate 3.NumberOut Dup=Separate 3.NumberOut Dup + 1:NEXT(334$);


;
;
;     Model statements for module:  Process 7
;
334$          ASSIGN:        Process 7.NumberIn=Process 7.NumberIn + 1:
                             Process 7.WIP=Process 7.WIP+1;
2113$         STACK,         1:Save:NEXT(2087$);

2087$         QUEUE,         Process 7.Queue;
2086$         SEIZE,         2,VA:
                             Resource 3,1:NEXT(2085$);

2085$         DELAY:         HoursToBaseTime(expo(10/departurea1# c1,31)),,VA:NEXT(2128$);

2128$         ASSIGN:        Process 7.WaitTime=Process 7.WaitTime + Diff.WaitTime;
2092$         TALLY:         Process 7.WaitTimePerEntity,Diff.WaitTime,1;
2094$         TALLY:         Process 7.TotalTimePerEntity,Diff.StartTime,1;
2118$         ASSIGN:        Process 7.VATime=Process 7.VATime + Diff.VATime;
2119$         TALLY:         Process 7.VATimePerEntity,Diff.VATime,1;
2084$         RELEASE:       Resource 3,1;
2133$         STACK,         1:Destroy:NEXT(2132$);

2132$         ASSIGN:        Process 7.NumberOut=Process 7.NumberOut + 1:
                             Process 7.WIP=Process 7.WIP-1:NEXT(326$);


;
;
;     Model statements for module:  Assign 59
;
326$          ASSIGN:        type=1:NEXT(97$);


;
;
;     Model statements for module:  Assign 67
;
331$          ASSIGN:        departurea2# c1=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,96):NEXT(336$);


;
;
;     Model statements for module:  Decide 97
;
336$          BRANCH,        1:
                             If,departurea2# c1==0,333$,Yes:
                             If,departurea2# c1==1,338$,Yes:
                             Else,337$,Yes;

;
;
;     Model statements for module:  Separate 4
;
337$          DUPLICATE,     100 - 50:
                             departurea2# c1-1,2139$,50:NEXT(2138$);

2138$         ASSIGN:        Separate 4.NumberOut Orig=Separate 4.NumberOut Orig + 1:NEXT(338$);

2139$         ASSIGN:        Separate 4.NumberOut Dup=Separate 4.NumberOut Dup + 1:NEXT(338$);


;
;
;     Model statements for module:  Process 9
;
338$          ASSIGN:        Process 9.NumberIn=Process 9.NumberIn + 1:
                             Process 9.WIP=Process 9.WIP+1;
2169$         STACK,         1:Save:NEXT(2143$);

2143$         QUEUE,         Process 9.Queue;
2142$         SEIZE,         2,VA:
                             Resource 4,1:NEXT(2141$);

2141$         DELAY:         HoursToBaseTime(expo(14/departurea2# c1,32)),,VA:NEXT(2184$);

2184$         ASSIGN:        Process 9.WaitTime=Process 9.WaitTime + Diff.WaitTime;
2148$         TALLY:         Process 9.WaitTimePerEntity,Diff.WaitTime,1;
2150$         TALLY:         Process 9.TotalTimePerEntity,Diff.StartTime,1;
2174$         ASSIGN:        Process 9.VATime=Process 9.VATime + Diff.VATime;
2175$         TALLY:         Process 9.VATimePerEntity,Diff.VATime,1;
2140$         RELEASE:       Resource 4,1;
2189$         STACK,         1:Destroy:NEXT(2188$);

2188$         ASSIGN:        Process 9.NumberOut=Process 9.NumberOut + 1:
                             Process 9.WIP=Process 9.WIP-1:NEXT(326$);


;
;
;     Model statements for module:  Create 19
;

2191$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c1:MinutesToBaseTime(1440):NEXT(2192$);

2192$         ASSIGN:        Create for shipment b shift2 c1.NumberOut=Create for shipment b shift2 c1.NumberOut + 1:NEXT(339$);


;
;
;     Model statements for module:  Create 39
;

2195$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c2:MinutesToBaseTime(1440):NEXT(2196$);

2196$         ASSIGN:        Create for shipment b shift1 c2.NumberOut=Create for shipment b shift1 c2.NumberOut + 1:NEXT(370$);


;
;
;     Model statements for module:  Decide 145
;
370$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2199$,Yes:
                             Else,2200$,Yes;
2199$         ASSIGN:        Decide 145.NumberOut True=Decide 145.NumberOut True + 1:NEXT(371$);

2200$         ASSIGN:        Decide 145.NumberOut False=Decide 145.NumberOut False + 1:NEXT(372$);


;
;
;     Model statements for module:  Assign 105
;
371$          ASSIGN:        departureb1# c2=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,103):NEXT(373$);


;
;
;     Model statements for module:  Decide 146
;
373$          BRANCH,        1:
                             If,departureb1# c2==0,364$,Yes:
                             If,departureb1# c2==1,374$,Yes:
                             Else,375$,Yes;

;
;
;     Model statements for module:  Separate 27
;
375$          DUPLICATE,     100 - 50:
                             departureb1# c2-1,2205$,50:NEXT(2204$);

2204$         ASSIGN:        Separate 27.NumberOut Orig=Separate 27.NumberOut Orig + 1:NEXT(374$);

2205$         ASSIGN:        Separate 27.NumberOut Dup=Separate 27.NumberOut Dup + 1:NEXT(374$);


;
;
;     Model statements for module:  Process 32
;
374$          ASSIGN:        Process 32.NumberIn=Process 32.NumberIn + 1:
                             Process 32.WIP=Process 32.WIP+1;
2235$         STACK,         1:Save:NEXT(2209$);

2209$         QUEUE,         Process 32.Queue;
2208$         SEIZE,         2,VA:
                             Resource 20,1:NEXT(2207$);

2207$         DELAY:         HoursToBaseTime(expo(10/departureb1# c2,39)),,VA:NEXT(2250$);

2250$         ASSIGN:        Process 32.WaitTime=Process 32.WaitTime + Diff.WaitTime;
2214$         TALLY:         Process 32.WaitTimePerEntity,Diff.WaitTime,1;
2216$         TALLY:         Process 32.TotalTimePerEntity,Diff.StartTime,1;
2240$         ASSIGN:        Process 32.VATime=Process 32.VATime + Diff.VATime;
2241$         TALLY:         Process 32.VATimePerEntity,Diff.VATime,1;
2206$         RELEASE:       Resource 20,1;
2255$         STACK,         1:Destroy:NEXT(2254$);

2254$         ASSIGN:        Process 32.NumberOut=Process 32.NumberOut + 1:
                             Process 32.WIP=Process 32.WIP-1:NEXT(358$);


;
;
;     Model statements for module:  Assign 101
;
358$          ASSIGN:        type=2:NEXT(97$);


;
;
;     Model statements for module:  Dispose 24
;
364$          ASSIGN:        Dispose 24.NumberOut=Dispose 24.NumberOut + 1;
2257$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 106
;
372$          ASSIGN:        departureb2# c2=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,104)
                             :NEXT(376$);


;
;
;     Model statements for module:  Decide 147
;
376$          BRANCH,        1:
                             If,departureb2# c2==0,364$,Yes:
                             If,departureb2# c2==1,377$,Yes:
                             Else,378$,Yes;

;
;
;     Model statements for module:  Separate 28
;
378$          DUPLICATE,     100 - 50:
                             departureb2# c2-1,2262$,50:NEXT(2261$);

2261$         ASSIGN:        Separate 28.NumberOut Orig=Separate 28.NumberOut Orig + 1:NEXT(377$);

2262$         ASSIGN:        Separate 28.NumberOut Dup=Separate 28.NumberOut Dup + 1:NEXT(377$);


;
;
;     Model statements for module:  Process 33
;
377$          ASSIGN:        Process 33.NumberIn=Process 33.NumberIn + 1:
                             Process 33.WIP=Process 33.WIP+1;
2292$         STACK,         1:Save:NEXT(2266$);

2266$         QUEUE,         Process 33.Queue;
2265$         SEIZE,         2,VA:
                             Resource 21,1:NEXT(2264$);

2264$         DELAY:         HoursToBaseTime(expo(14/departureb2# c2,40)),,VA:NEXT(2307$);

2307$         ASSIGN:        Process 33.WaitTime=Process 33.WaitTime + Diff.WaitTime;
2271$         TALLY:         Process 33.WaitTimePerEntity,Diff.WaitTime,1;
2273$         TALLY:         Process 33.TotalTimePerEntity,Diff.StartTime,1;
2297$         ASSIGN:        Process 33.VATime=Process 33.VATime + Diff.VATime;
2298$         TALLY:         Process 33.VATimePerEntity,Diff.VATime,1;
2263$         RELEASE:       Resource 21,1;
2312$         STACK,         1:Destroy:NEXT(2311$);

2311$         ASSIGN:        Process 33.NumberOut=Process 33.NumberOut + 1:
                             Process 33.WIP=Process 33.WIP-1:NEXT(358$);


;
;
;     Model statements for module:  Create 40
;

2314$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c2:MinutesToBaseTime(1440):NEXT(2315$);

2315$         ASSIGN:        Create for shipment c shift1 c2.NumberOut=Create for shipment c shift1 c2.NumberOut + 1:NEXT(379$);


;
;
;     Model statements for module:  Decide 148
;
379$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2318$,Yes:
                             Else,2319$,Yes;
2318$         ASSIGN:        Decide 148.NumberOut True=Decide 148.NumberOut True + 1:NEXT(380$);

2319$         ASSIGN:        Decide 148.NumberOut False=Decide 148.NumberOut False + 1:NEXT(381$);


;
;
;     Model statements for module:  Assign 107
;
380$          ASSIGN:        departurec1# c2=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,105):NEXT(382$);


;
;
;     Model statements for module:  Decide 149
;
382$          BRANCH,        1:
                             If,departurec1# c2==0,364$,Yes:
                             If,departurec1# c2==1,383$,Yes:
                             Else,384$,Yes;

;
;
;     Model statements for module:  Separate 29
;
384$          DUPLICATE,     100 - 50:
                             departurec1# c2-1,2324$,50:NEXT(2323$);

2323$         ASSIGN:        Separate 29.NumberOut Orig=Separate 29.NumberOut Orig + 1:NEXT(383$);

2324$         ASSIGN:        Separate 29.NumberOut Dup=Separate 29.NumberOut Dup + 1:NEXT(383$);


;
;
;     Model statements for module:  Process 34
;
383$          ASSIGN:        Process 34.NumberIn=Process 34.NumberIn + 1:
                             Process 34.WIP=Process 34.WIP+1;
2354$         STACK,         1:Save:NEXT(2328$);

2328$         QUEUE,         Process 34.Queue;
2327$         SEIZE,         2,VA:
                             Resource 22,1:NEXT(2326$);

2326$         DELAY:         HoursToBaseTime(expo(10/departurec1# c2,41)),,VA:NEXT(2369$);

2369$         ASSIGN:        Process 34.WaitTime=Process 34.WaitTime + Diff.WaitTime;
2333$         TALLY:         Process 34.WaitTimePerEntity,Diff.WaitTime,1;
2335$         TALLY:         Process 34.TotalTimePerEntity,Diff.StartTime,1;
2359$         ASSIGN:        Process 34.VATime=Process 34.VATime + Diff.VATime;
2360$         TALLY:         Process 34.VATimePerEntity,Diff.VATime,1;
2325$         RELEASE:       Resource 22,1;
2374$         STACK,         1:Destroy:NEXT(2373$);

2373$         ASSIGN:        Process 34.NumberOut=Process 34.NumberOut + 1:
                             Process 34.WIP=Process 34.WIP-1:NEXT(359$);


;
;
;     Model statements for module:  Assign 102
;
359$          ASSIGN:        type=3:NEXT(97$);


;
;
;     Model statements for module:  Assign 108
;
381$          ASSIGN:        departurec2# c2=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,106):NEXT(385$);


;
;
;     Model statements for module:  Decide 150
;
385$          BRANCH,        1:
                             If,departurec2# c2==0,364$,Yes:
                             If,departurec2# c2==1,386$,Yes:
                             Else,387$,Yes;

;
;
;     Model statements for module:  Separate 30
;
387$          DUPLICATE,     100 - 50:
                             departurec2# c2-1,2380$,50:NEXT(2379$);

2379$         ASSIGN:        Separate 30.NumberOut Orig=Separate 30.NumberOut Orig + 1:NEXT(386$);

2380$         ASSIGN:        Separate 30.NumberOut Dup=Separate 30.NumberOut Dup + 1:NEXT(386$);


;
;
;     Model statements for module:  Process 35
;
386$          ASSIGN:        Process 35.NumberIn=Process 35.NumberIn + 1:
                             Process 35.WIP=Process 35.WIP+1;
2410$         STACK,         1:Save:NEXT(2384$);

2384$         QUEUE,         Process 35.Queue;
2383$         SEIZE,         2,VA:
                             Resource 23,1:NEXT(2382$);

2382$         DELAY:         HoursToBaseTime(expo(14/departurec2# c2,42)),,VA:NEXT(2425$);

2425$         ASSIGN:        Process 35.WaitTime=Process 35.WaitTime + Diff.WaitTime;
2389$         TALLY:         Process 35.WaitTimePerEntity,Diff.WaitTime,1;
2391$         TALLY:         Process 35.TotalTimePerEntity,Diff.StartTime,1;
2415$         ASSIGN:        Process 35.VATime=Process 35.VATime + Diff.VATime;
2416$         TALLY:         Process 35.VATimePerEntity,Diff.VATime,1;
2381$         RELEASE:       Resource 23,1;
2430$         STACK,         1:Destroy:NEXT(2429$);

2429$         ASSIGN:        Process 35.NumberOut=Process 35.NumberOut + 1:
                             Process 35.WIP=Process 35.WIP-1:NEXT(359$);


;
;
;     Model statements for module:  Create 42
;

2432$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c2:MinutesToBaseTime(1440):NEXT(2433$);

2433$         ASSIGN:        Create for shipmenta shift2 c2.NumberOut=Create for shipmenta shift2 c2.NumberOut + 1:NEXT(361$);


;
;
;     Model statements for module:  Decide 142
;
361$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2436$,Yes:
                             Else,2437$,Yes;
2436$         ASSIGN:        Decide 142.NumberOut True=Decide 142.NumberOut True + 1:NEXT(360$);

2437$         ASSIGN:        Decide 142.NumberOut False=Decide 142.NumberOut False + 1:NEXT(362$);


;
;
;     Model statements for module:  Assign 103
;
360$          ASSIGN:        departurea1# c2=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,101):NEXT(363$);


;
;
;     Model statements for module:  Decide 143
;
363$          BRANCH,        1:
                             If,departurea1# c2==0,364$,Yes:
                             If,departurea1# c2==1,365$,Yes:
                             Else,366$,Yes;

;
;
;     Model statements for module:  Separate 25
;
366$          DUPLICATE,     100 - 50:
                             departurea1# c2-1,2442$,50:NEXT(2441$);

2441$         ASSIGN:        Separate 25.NumberOut Orig=Separate 25.NumberOut Orig + 1:NEXT(365$);

2442$         ASSIGN:        Separate 25.NumberOut Dup=Separate 25.NumberOut Dup + 1:NEXT(365$);


;
;
;     Model statements for module:  Process 30
;
365$          ASSIGN:        Process 30.NumberIn=Process 30.NumberIn + 1:
                             Process 30.WIP=Process 30.WIP+1;
2472$         STACK,         1:Save:NEXT(2446$);

2446$         QUEUE,         Process 30.Queue;
2445$         SEIZE,         2,VA:
                             Resource 18,1:NEXT(2444$);

2444$         DELAY:         HoursToBaseTime(expo(10/departurea1# c2,37)),,VA:NEXT(2487$);

2487$         ASSIGN:        Process 30.WaitTime=Process 30.WaitTime + Diff.WaitTime;
2451$         TALLY:         Process 30.WaitTimePerEntity,Diff.WaitTime,1;
2453$         TALLY:         Process 30.TotalTimePerEntity,Diff.StartTime,1;
2477$         ASSIGN:        Process 30.VATime=Process 30.VATime + Diff.VATime;
2478$         TALLY:         Process 30.VATimePerEntity,Diff.VATime,1;
2443$         RELEASE:       Resource 18,1;
2492$         STACK,         1:Destroy:NEXT(2491$);

2491$         ASSIGN:        Process 30.NumberOut=Process 30.NumberOut + 1:
                             Process 30.WIP=Process 30.WIP-1:NEXT(357$);


;
;
;     Model statements for module:  Assign 100
;
357$          ASSIGN:        type=1:NEXT(97$);


;
;
;     Model statements for module:  Assign 104
;
362$          ASSIGN:        departurea2# c2=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,102):NEXT(367$);


;
;
;     Model statements for module:  Decide 144
;
367$          BRANCH,        1:
                             If,departurea2# c2==0,364$,Yes:
                             If,departurea2# c2==1,369$,Yes:
                             Else,368$,Yes;

;
;
;     Model statements for module:  Separate 26
;
368$          DUPLICATE,     100 - 50:
                             departurea2# c2-1,2498$,50:NEXT(2497$);

2497$         ASSIGN:        Separate 26.NumberOut Orig=Separate 26.NumberOut Orig + 1:NEXT(369$);

2498$         ASSIGN:        Separate 26.NumberOut Dup=Separate 26.NumberOut Dup + 1:NEXT(369$);


;
;
;     Model statements for module:  Process 31
;
369$          ASSIGN:        Process 31.NumberIn=Process 31.NumberIn + 1:
                             Process 31.WIP=Process 31.WIP+1;
2528$         STACK,         1:Save:NEXT(2502$);

2502$         QUEUE,         Process 31.Queue;
2501$         SEIZE,         2,VA:
                             Resource 19,1:NEXT(2500$);

2500$         DELAY:         HoursToBaseTime(expo(14/departurea2# c2,38)),,VA:NEXT(2543$);

2543$         ASSIGN:        Process 31.WaitTime=Process 31.WaitTime + Diff.WaitTime;
2507$         TALLY:         Process 31.WaitTimePerEntity,Diff.WaitTime,1;
2509$         TALLY:         Process 31.TotalTimePerEntity,Diff.StartTime,1;
2533$         ASSIGN:        Process 31.VATime=Process 31.VATime + Diff.VATime;
2534$         TALLY:         Process 31.VATimePerEntity,Diff.VATime,1;
2499$         RELEASE:       Resource 19,1;
2548$         STACK,         1:Destroy:NEXT(2547$);

2547$         ASSIGN:        Process 31.NumberOut=Process 31.NumberOut + 1:
                             Process 31.WIP=Process 31.WIP-1:NEXT(357$);


;
;
;     Model statements for module:  Create 43
;

2550$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c2:MinutesToBaseTime(1440):NEXT(2551$);

2551$         ASSIGN:        Create for shipment b shift2 c2.NumberOut=Create for shipment b shift2 c2.NumberOut + 1:NEXT(370$);


;
;
;     Model statements for module:  Create 54
;

2554$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c3:MinutesToBaseTime(1440):NEXT(2555$);

2555$         ASSIGN:        Create for shipment b shift1 c3.NumberOut=Create for shipment b shift1 c3.NumberOut + 1:NEXT(401$);


;
;
;     Model statements for module:  Decide 166
;
401$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2558$,Yes:
                             Else,2559$,Yes;
2558$         ASSIGN:        Decide 166.NumberOut True=Decide 166.NumberOut True + 1:NEXT(402$);

2559$         ASSIGN:        Decide 166.NumberOut False=Decide 166.NumberOut False + 1:NEXT(403$);


;
;
;     Model statements for module:  Assign 126
;
402$          ASSIGN:        departureb1# c3=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,109):NEXT(404$);


;
;
;     Model statements for module:  Decide 167
;
404$          BRANCH,        1:
                             If,departureb1# c3==0,395$,Yes:
                             If,departureb1# c3==1,405$,Yes:
                             Else,406$,Yes;

;
;
;     Model statements for module:  Separate 39
;
406$          DUPLICATE,     100 - 50:
                             departureb1# c3-1,2564$,50:NEXT(2563$);

2563$         ASSIGN:        Separate 39.NumberOut Orig=Separate 39.NumberOut Orig + 1:NEXT(405$);

2564$         ASSIGN:        Separate 39.NumberOut Dup=Separate 39.NumberOut Dup + 1:NEXT(405$);


;
;
;     Model statements for module:  Process 44
;
405$          ASSIGN:        Process 44.NumberIn=Process 44.NumberIn + 1:
                             Process 44.WIP=Process 44.WIP+1;
2594$         STACK,         1:Save:NEXT(2568$);

2568$         QUEUE,         Process 44.Queue;
2567$         SEIZE,         2,VA:
                             Resource 32,1:NEXT(2566$);

2566$         DELAY:         HoursToBaseTime(expo(10/departureb1# c3,45)),,VA:NEXT(2609$);

2609$         ASSIGN:        Process 44.WaitTime=Process 44.WaitTime + Diff.WaitTime;
2573$         TALLY:         Process 44.WaitTimePerEntity,Diff.WaitTime,1;
2575$         TALLY:         Process 44.TotalTimePerEntity,Diff.StartTime,1;
2599$         ASSIGN:        Process 44.VATime=Process 44.VATime + Diff.VATime;
2600$         TALLY:         Process 44.VATimePerEntity,Diff.VATime,1;
2565$         RELEASE:       Resource 32,1;
2614$         STACK,         1:Destroy:NEXT(2613$);

2613$         ASSIGN:        Process 44.NumberOut=Process 44.NumberOut + 1:
                             Process 44.WIP=Process 44.WIP-1:NEXT(389$);


;
;
;     Model statements for module:  Assign 122
;
389$          ASSIGN:        type=2:NEXT(97$);


;
;
;     Model statements for module:  Dispose 26
;
395$          ASSIGN:        Dispose 26.NumberOut=Dispose 26.NumberOut + 1;
2616$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 127
;
403$          ASSIGN:        departureb2# c3=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,110)
                             :NEXT(407$);


;
;
;     Model statements for module:  Decide 168
;
407$          BRANCH,        1:
                             If,departureb2# c3==0,395$,Yes:
                             If,departureb2# c3==1,408$,Yes:
                             Else,409$,Yes;

;
;
;     Model statements for module:  Separate 40
;
409$          DUPLICATE,     100 - 50:
                             departureb2# c3-1,2621$,50:NEXT(2620$);

2620$         ASSIGN:        Separate 40.NumberOut Orig=Separate 40.NumberOut Orig + 1:NEXT(408$);

2621$         ASSIGN:        Separate 40.NumberOut Dup=Separate 40.NumberOut Dup + 1:NEXT(408$);


;
;
;     Model statements for module:  Process 45
;
408$          ASSIGN:        Process 45.NumberIn=Process 45.NumberIn + 1:
                             Process 45.WIP=Process 45.WIP+1;
2651$         STACK,         1:Save:NEXT(2625$);

2625$         QUEUE,         Process 45.Queue;
2624$         SEIZE,         2,VA:
                             Resource 33,1:NEXT(2623$);

2623$         DELAY:         HoursToBaseTime(expo(14/departureb2# c3,46)),,VA:NEXT(2666$);

2666$         ASSIGN:        Process 45.WaitTime=Process 45.WaitTime + Diff.WaitTime;
2630$         TALLY:         Process 45.WaitTimePerEntity,Diff.WaitTime,1;
2632$         TALLY:         Process 45.TotalTimePerEntity,Diff.StartTime,1;
2656$         ASSIGN:        Process 45.VATime=Process 45.VATime + Diff.VATime;
2657$         TALLY:         Process 45.VATimePerEntity,Diff.VATime,1;
2622$         RELEASE:       Resource 33,1;
2671$         STACK,         1:Destroy:NEXT(2670$);

2670$         ASSIGN:        Process 45.NumberOut=Process 45.NumberOut + 1:
                             Process 45.WIP=Process 45.WIP-1:NEXT(389$);


;
;
;     Model statements for module:  Create 55
;

2673$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c3:MinutesToBaseTime(1440):NEXT(2674$);

2674$         ASSIGN:        Create for shipment c shift1 c3.NumberOut=Create for shipment c shift1 c3.NumberOut + 1:NEXT(410$);


;
;
;     Model statements for module:  Decide 169
;
410$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2677$,Yes:
                             Else,2678$,Yes;
2677$         ASSIGN:        Decide 169.NumberOut True=Decide 169.NumberOut True + 1:NEXT(411$);

2678$         ASSIGN:        Decide 169.NumberOut False=Decide 169.NumberOut False + 1:NEXT(412$);


;
;
;     Model statements for module:  Assign 128
;
411$          ASSIGN:        departurec1# c3=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,111):NEXT(413$);


;
;
;     Model statements for module:  Decide 170
;
413$          BRANCH,        1:
                             If,departurec1# c3==0,395$,Yes:
                             If,departurec1# c3==1,414$,Yes:
                             Else,415$,Yes;

;
;
;     Model statements for module:  Separate 41
;
415$          DUPLICATE,     100 - 50:
                             departurec1# c3-1,2683$,50:NEXT(2682$);

2682$         ASSIGN:        Separate 41.NumberOut Orig=Separate 41.NumberOut Orig + 1:NEXT(414$);

2683$         ASSIGN:        Separate 41.NumberOut Dup=Separate 41.NumberOut Dup + 1:NEXT(414$);


;
;
;     Model statements for module:  Process 46
;
414$          ASSIGN:        Process 46.NumberIn=Process 46.NumberIn + 1:
                             Process 46.WIP=Process 46.WIP+1;
2713$         STACK,         1:Save:NEXT(2687$);

2687$         QUEUE,         Process 46.Queue;
2686$         SEIZE,         2,VA:
                             Resource 34,1:NEXT(2685$);

2685$         DELAY:         HoursToBaseTime(expo(10/departurec1# c3,47)),,VA:NEXT(2728$);

2728$         ASSIGN:        Process 46.WaitTime=Process 46.WaitTime + Diff.WaitTime;
2692$         TALLY:         Process 46.WaitTimePerEntity,Diff.WaitTime,1;
2694$         TALLY:         Process 46.TotalTimePerEntity,Diff.StartTime,1;
2718$         ASSIGN:        Process 46.VATime=Process 46.VATime + Diff.VATime;
2719$         TALLY:         Process 46.VATimePerEntity,Diff.VATime,1;
2684$         RELEASE:       Resource 34,1;
2733$         STACK,         1:Destroy:NEXT(2732$);

2732$         ASSIGN:        Process 46.NumberOut=Process 46.NumberOut + 1:
                             Process 46.WIP=Process 46.WIP-1:NEXT(390$);


;
;
;     Model statements for module:  Assign 123
;
390$          ASSIGN:        type=3:NEXT(97$);


;
;
;     Model statements for module:  Assign 129
;
412$          ASSIGN:        departurec2# c3=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,112):NEXT(416$);


;
;
;     Model statements for module:  Decide 171
;
416$          BRANCH,        1:
                             If,departurec2# c3==0,395$,Yes:
                             If,departurec2# c3==1,417$,Yes:
                             Else,418$,Yes;

;
;
;     Model statements for module:  Separate 42
;
418$          DUPLICATE,     100 - 50:
                             departurec2# c3-1,2739$,50:NEXT(2738$);

2738$         ASSIGN:        Separate 42.NumberOut Orig=Separate 42.NumberOut Orig + 1:NEXT(417$);

2739$         ASSIGN:        Separate 42.NumberOut Dup=Separate 42.NumberOut Dup + 1:NEXT(417$);


;
;
;     Model statements for module:  Process 47
;
417$          ASSIGN:        Process 47.NumberIn=Process 47.NumberIn + 1:
                             Process 47.WIP=Process 47.WIP+1;
2769$         STACK,         1:Save:NEXT(2743$);

2743$         QUEUE,         Process 47.Queue;
2742$         SEIZE,         2,VA:
                             Resource 35,1:NEXT(2741$);

2741$         DELAY:         HoursToBaseTime(expo(14/departurec2# c3,48)),,VA:NEXT(2784$);

2784$         ASSIGN:        Process 47.WaitTime=Process 47.WaitTime + Diff.WaitTime;
2748$         TALLY:         Process 47.WaitTimePerEntity,Diff.WaitTime,1;
2750$         TALLY:         Process 47.TotalTimePerEntity,Diff.StartTime,1;
2774$         ASSIGN:        Process 47.VATime=Process 47.VATime + Diff.VATime;
2775$         TALLY:         Process 47.VATimePerEntity,Diff.VATime,1;
2740$         RELEASE:       Resource 35,1;
2789$         STACK,         1:Destroy:NEXT(2788$);

2788$         ASSIGN:        Process 47.NumberOut=Process 47.NumberOut + 1:
                             Process 47.WIP=Process 47.WIP-1:NEXT(390$);


;
;
;     Model statements for module:  Create 57
;

2791$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c3:MinutesToBaseTime(1440):NEXT(2792$);

2792$         ASSIGN:        Create for shipmenta shift2 c3.NumberOut=Create for shipmenta shift2 c3.NumberOut + 1:NEXT(392$);


;
;
;     Model statements for module:  Decide 163
;
392$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2795$,Yes:
                             Else,2796$,Yes;
2795$         ASSIGN:        Decide 163.NumberOut True=Decide 163.NumberOut True + 1:NEXT(391$);

2796$         ASSIGN:        Decide 163.NumberOut False=Decide 163.NumberOut False + 1:NEXT(393$);


;
;
;     Model statements for module:  Assign 124
;
391$          ASSIGN:        departurea1# c3=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,107):NEXT(394$);


;
;
;     Model statements for module:  Decide 164
;
394$          BRANCH,        1:
                             If,departurea1# c3==0,395$,Yes:
                             If,departurea1# c3==1,396$,Yes:
                             Else,397$,Yes;

;
;
;     Model statements for module:  Separate 37
;
397$          DUPLICATE,     100 - 50:
                             departurea1# c3-1,2801$,50:NEXT(2800$);

2800$         ASSIGN:        Separate 37.NumberOut Orig=Separate 37.NumberOut Orig + 1:NEXT(396$);

2801$         ASSIGN:        Separate 37.NumberOut Dup=Separate 37.NumberOut Dup + 1:NEXT(396$);


;
;
;     Model statements for module:  Process 42
;
396$          ASSIGN:        Process 42.NumberIn=Process 42.NumberIn + 1:
                             Process 42.WIP=Process 42.WIP+1;
2831$         STACK,         1:Save:NEXT(2805$);

2805$         QUEUE,         Process 42.Queue;
2804$         SEIZE,         2,VA:
                             Resource 30,1:NEXT(2803$);

2803$         DELAY:         HoursToBaseTime(expo(10/departurea1# c3,43)),,VA:NEXT(2846$);

2846$         ASSIGN:        Process 42.WaitTime=Process 42.WaitTime + Diff.WaitTime;
2810$         TALLY:         Process 42.WaitTimePerEntity,Diff.WaitTime,1;
2812$         TALLY:         Process 42.TotalTimePerEntity,Diff.StartTime,1;
2836$         ASSIGN:        Process 42.VATime=Process 42.VATime + Diff.VATime;
2837$         TALLY:         Process 42.VATimePerEntity,Diff.VATime,1;
2802$         RELEASE:       Resource 30,1;
2851$         STACK,         1:Destroy:NEXT(2850$);

2850$         ASSIGN:        Process 42.NumberOut=Process 42.NumberOut + 1:
                             Process 42.WIP=Process 42.WIP-1:NEXT(388$);


;
;
;     Model statements for module:  Assign 121
;
388$          ASSIGN:        type=1:NEXT(97$);


;
;
;     Model statements for module:  Assign 125
;
393$          ASSIGN:        departurea2# c3=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,108):NEXT(398$);


;
;
;     Model statements for module:  Decide 165
;
398$          BRANCH,        1:
                             If,departurea2# c3==0,395$,Yes:
                             If,departurea2# c3==1,400$,Yes:
                             Else,399$,Yes;

;
;
;     Model statements for module:  Separate 38
;
399$          DUPLICATE,     100 - 50:
                             departurea2# c3-1,2857$,50:NEXT(2856$);

2856$         ASSIGN:        Separate 38.NumberOut Orig=Separate 38.NumberOut Orig + 1:NEXT(400$);

2857$         ASSIGN:        Separate 38.NumberOut Dup=Separate 38.NumberOut Dup + 1:NEXT(400$);


;
;
;     Model statements for module:  Process 43
;
400$          ASSIGN:        Process 43.NumberIn=Process 43.NumberIn + 1:
                             Process 43.WIP=Process 43.WIP+1;
2887$         STACK,         1:Save:NEXT(2861$);

2861$         QUEUE,         Process 43.Queue;
2860$         SEIZE,         2,VA:
                             Resource 31,1:NEXT(2859$);

2859$         DELAY:         HoursToBaseTime(expo(14/departurea2# c3,44)),,VA:NEXT(2902$);

2902$         ASSIGN:        Process 43.WaitTime=Process 43.WaitTime + Diff.WaitTime;
2866$         TALLY:         Process 43.WaitTimePerEntity,Diff.WaitTime,1;
2868$         TALLY:         Process 43.TotalTimePerEntity,Diff.StartTime,1;
2892$         ASSIGN:        Process 43.VATime=Process 43.VATime + Diff.VATime;
2893$         TALLY:         Process 43.VATimePerEntity,Diff.VATime,1;
2858$         RELEASE:       Resource 31,1;
2907$         STACK,         1:Destroy:NEXT(2906$);

2906$         ASSIGN:        Process 43.NumberOut=Process 43.NumberOut + 1:
                             Process 43.WIP=Process 43.WIP-1:NEXT(388$);


;
;
;     Model statements for module:  Create 58
;

2909$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c3:MinutesToBaseTime(1440):NEXT(2910$);

2910$         ASSIGN:        Create for shipment b shift2 c3.NumberOut=Create for shipment b shift2 c3.NumberOut + 1:NEXT(401$);


;
;
;     Model statements for module:  Create 101
;

2913$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c1:MinutesToBaseTime(1440):NEXT(2914$);

2914$         ASSIGN:        Create for shipmenta shift1 c1.NumberOut=Create for shipmenta shift1 c1.NumberOut + 1:NEXT(330$);


;
;
;     Model statements for module:  Create 102
;

2917$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c2:MinutesToBaseTime(1440):NEXT(2918$);

2918$         ASSIGN:        Create for shipmenta shift1 c2.NumberOut=Create for shipmenta shift1 c2.NumberOut + 1:NEXT(361$);


;
;
;     Model statements for module:  Create 104
;

2921$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c3:MinutesToBaseTime(1440):NEXT(2922$);

2922$         ASSIGN:        Create for shipmenta shift1 c3.NumberOut=Create for shipmenta shift1 c3.NumberOut + 1:NEXT(392$);


;
;
;     Model statements for module:  Create 109
;

2925$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c1:MinutesToBaseTime(1440):NEXT(2926$);

2926$         ASSIGN:        Create for shipment c shift2 c1.NumberOut=Create for shipment c shift2 c1.NumberOut + 1:NEXT(348$);


;
;
;     Model statements for module:  Create 110
;

2929$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c2:MinutesToBaseTime(1440):NEXT(2930$);

2930$         ASSIGN:        Create for shipment c shift2 c2.NumberOut=Create for shipment c shift2 c2.NumberOut + 1:NEXT(379$);


;
;
;     Model statements for module:  Create 111
;

2933$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c3:MinutesToBaseTime(1440):NEXT(2934$);

2934$         ASSIGN:        Create for shipment c shift2 c3.NumberOut=Create for shipment c shift2 c3.NumberOut + 1:NEXT(410$);









